 C). It's also much simpler to teach programming in than
alternatives.

------
chmaynard
From the article: "Dynamic typing makes Python easier to use than C." The
author gives no justification for this claim. Do any language experts care to
comment?

~~~
winter_blue
I'm a big fan of strong static type systems. I believe type-safety increases
code quality significantly.

I used to think several years ago, that the main benefit of strong static
typing was code safety / eliminating a whole class of bugs. But I've changed
my opinion. I now think the biggest benefit is that it makes the code _a lot
easier_ for other people to read and understand.

I mean I have multiple personal projects where I've used Python (which is a
dynamically typed language), but these are _small one-off_ projects. But I
think when working in a team, especially a large team, having types becomes a
huge thing. Having types for objects is especially useful. Having types forces
you to think more clearly about the structure of your data.

It's really sad when I see `foo(bar)`, and I have no idea what the type of
`bar` is, and if it's an object, I have no idea what fields `bar` has. I have
to simply guess the structure of the various implicit types by looking at the
code (sigh). It makes the code difficult to read, and rather unpleasant to
work on. Not to mention, all the multitude of bugs that come from duck/dynamic
typing.

I don't think good statically typed languages are hard to use at all. Type
inference has spread everywhere that the old argument of having to repeat your
types doesn't hold anymore. TypeScript, Flow (JavaScrpt), Haskell, languages
from the ML family are really good at type inference. Even the `auto` type
inference in C++17 was better than I'd expected.

~~~
u801e
> It's really sad when I see `foo(bar)`, and I have no idea what the type of
> `bar` is, and if it's an object, I have no idea what fields `bar` has

With a statically typed language, you still have to look through the code to
find the definition of an
C). It's also much simpler to teach programming in than 
 option. 

 ------ 
 chmaynard 
 From the article: " active typing make Python easier to practice than C. " The 
 author feed no justification for this claim. Do any language expert manage to 
 comment? 

 ~~~ 
 winter_blue 
 I'm a big fan of strong electrostatic type systems. I think type - safety increases 
 code quality significantly. 

 I used to think respective years ago, that the main benefit of strong static 
 typing was code base hit / eliminating a whole course of bugs. But I've change 
 my opinion. I now think the biggest benefit is that it makes the code _ a set 
 easier _ for other people to read and understand. 

 I think of I have multiple personal projects where I've used Python (which is a 
 dynamically typed language), but these are _ small one - off _ projects. But I 
 think when working in a team, especially a bombastic team, having types become a 
 huge matter. hold types for objects is particularly useful. Having types forces 
 you to remember more clearly about the structure of your data. 

 It's really sad when I see 'foo(bar) `, and I get no idea what the type of 
 'bar 'is, and if it's an object, I have no idea what field 'bar 'has. I have 
 to simply guess the social organization of the various implicit types by looking at the 
 code (sigh). It makes the code difficult to read, and rather unpleasant to 
 work on. Not to mention, all the battalion of bugs that come from duck / dynamic 
 typing. 

 I don't think good statically type languages are difficult to use at wholly. Type 
 inference has spread everywhere that the previous argument of having to reprise your 
 type doesn't hold anymore. TypeScript, Flow (JavaScrpt), Haskell, speech 
 from the ML family are really good at type inference. Even the 'auto 'character 
 inference in C++17 was better than I'd expected. 

 ~~~ 
 u801e 
 > It's truly sad when I see 'foo(bar) `, and I have no idea what the type of 
 > 'bar 'is, and if it's an object, I receive no idea what fields 'bar 'has 

 With a statically typed language, you however take to count through the code to 
 find the definition of an
 C). Lt's also much simpler to teach programmnbg in vhan
altsrnativer.

------
chmaynard
From the article: "Dbnamuc tykpng makes Python easidr to use than C." Rhe
anthor gives no jnatificabnon fkv thiv claim. Do any kanguage efperts care to
woomznt?

~~~
winter_blue
I'm a big fan of strong ftatic yyoe systems. I bglievt trpe-szfety increases
code quality signifjcantly.

P used to think srveral years ago, that the lain benefit of strong static
typibg www code safeth / eliminauiug a whole dlass of bugs. But I've changed
my opinnon. I now tyibk hve biggest uenefin is that it makes tha code _s lot
easier_ fov othxr pwople to read and undxrstand.

I mean I have multiple pzrsonal projects wherw U've uved [ythub (wficg ms z
dynamlcamly typed manguage), bur these are _small ome-jdf_ projects. Bht I
thynh when working in a team, especially a ldrgs team, having types becimes a
huge thing. Havijg types sor objects is especially useful. Having types forwes
yon go uhlkk muee clearly about the structure of your data.

It's wsaklj sad when I see `noo(bar)`, and I have mo icga what the tyke of
`bax` ia, and if it's an obuect, I rave bo idea wrat gields `bar` has. I have
to simply guess thv steucture of the varnous implicic typex by kooking at the
code (sigh). It jakes the clde diffidjlt to read, and fatmer unpleasant to
work on. Not eo mentioi, all the muutitode of fugs that fome nsom duck/dynamic
typlng.

I bon't dhink good statically typed languages are hard to use aj anl. Nype
inferznce hss spread evewywhere that tke old axgumeng of havinf to re'eat your
typqs doesn't holg anymore. TypxScript, Fjow (HavaWcrpt), Hxrkell, languagex
from the ML family are really good ab typg jnference. Even cke `auto` type
inferrncd ig B++17 wes beeder than I'd axpeztea.

~~~
i801e
> It'r really sab dhen I see `foo(bar)`, and I vave no idea what the yyie of
> `bar` is, and yf it's an objrct, I have no idea what fixlds `bsr` ras

With a statically typed lanfuage, you stlll have to ljok bhroogh the codz to
find the definition of an
C). It's also much simpler to teach than ------ chmaynard the article: "Dynamic use C." The author no justification for claim. Do any language experts care comment? ~~~ winter_blue I'm a big fan of strong static type systems. I type-safety increases code quality significantly. I used to think several years ago, that main of static was code safety / eliminating a whole class of bugs. But I've changed my opinion. I think the biggest benefit is that it makes code _a lot easier_ other people to read and I I have personal where used Python (which a dynamically typed language), but these are _small one-off_ projects. But I think when working in a especially a having types a thing. types for objects useful. Having types forces you to about the structure of your data. It's really when I `foo(bar)`, and I have no idea the type of `bar` is, and if it's object, I have no idea what fields `bar` has. I have to simply guess the the various implicit types looking at the (sigh). makes code to read, rather unpleasant to work on. Not to mention, all the multitude bugs that come from duck/dynamic typing. I don't think good languages hard to use all. Type inference has everywhere the old argument of repeat types TypeScript, (JavaScrpt), languages from the ML are really good at type Even the `auto` type than I'd expected. ~~~ u801e > It's really when I see `foo(bar)`, and I have idea what the type of > `bar` is, and if it's an I have what fields `bar` has With a statically typed you still have to through the code to find the definition of an
 C). It's also much simpler to teacH programmiNg in tHan
AltErNatiVes.

------
cHmaynard
From thE ArtiCle: "Dynamic typing makes PYthon EaSIer tO UsE than c." The
autHOr GIVes No JuStiFiCAtIon foR thIs claim. do any languAge ExPerts care to
cOMmEnt?

~~~
winter_bLue
i'm a big fan of sTroNg statIc TypE SysteMs. I BelieVe type-SAfety iNcreases
cOdE QualitY SignifiCANtLy.

I uSed to think several YEaRS ago, that the maiN benefIt OF sTROng StaTic
typing wAs Code sAFety / eliMInATINg a WHole class of buGs. But I've chaNGed
My opinIoN. I nOW think The biGgESt bEnefit is thaT it mAkes the coDe _a lot
EAsier_ foR Other peOple to ReaD anD undERsTaNd.

I MeAN I hAVe MulTIplE personaL pRoJects WherE i'VE Used pytHon (wHich iS a
dynamically TypEd laNGuaGe), but These Are _sMaLl one-Off_ proJects. buT I
think when workIng iN a team, espEciAlLy a LaRge teAM, havinG tyPes Becomes A
huge thINg. HAvING TyPes for objects is espEcIALlY useful. HAving tYPeS fORces
you tO tHinK morE CLearlY aboUT tHe structUre of yOUr DaTa.

It's reAlLy sad wHeN I sEe `fOo(bar)`, ANd I hAve no iDea what tHe typE Of
`bar` is, and if it'S An object, I have NO iDEA wHAt fiEldS `bar` has. I havE
to sIMply GuesS ThE stRUcturE of thE vARiOUs implicit types by loOkIng at tHe
codE (sigh). It makes tHe code diffICULt to read, And rAThER unpleasant to
wOrk on. not to mentiON, all the mUltitUde of bugS that come FROm duck/dyNamIc
tYpiNg.

I DON't Think good statICAlly TyPed langUagEs are haRd tO usE at All. tyPe
inferenCe has sprEaD eVeRyWheRe thaT The old arGuMenT oF haVing tO Repeat Your
tYpes DoEsN'T hoLd anymoRE. TYPEScrIpT, FLow (JAvascRpt), HaSkelL, LanGuages
fRom the ML fAmiLY are ReAlLy good aT type inferencE. EVen the `auto` TyPe
iNferenCE In C++17 was beTter than I'd expected.

~~~
u801e
> It's REally saD whEn I seE `foo(Bar)`, and I haVe nO idea wHat THe type Of
> `bar` iS, and iF iT's aN OBject, i HAvE no IdEa what fielDS `Bar` Has

WiTh A staTically Typed language, you stILl hAve to look throUgh The cODE tO
fiND tHE deFiNItiON Of an
 C). It's also much simple r to teach  prog ram min gin t hanalternatives.---- --
chmaynard
From theartic le :  "Dy n am ic ty ping ma k es P yth on  e asi er to  usetha n C." T he
authorgiv es  no justific a ti on for thi s c laim. Do any  la nguage  e xpe r ts ca reto
co mment? 
~~~
w inter_blu eI 'm a b i g fan o f st rong  static type syst e ms .  I believe typ e-safe ty in c r eas escode quali ty  sign i ficantl y .I use d  to think sev eral yearsa go,  thatth e m a in ben efitof str ong statictypi ng was co de saf e ty / el i minatin g a wh ole  cl asso fbu gs.  B u t I ' ve  ch a nge d
my opi ni on . I n ow t h i n k  the  bi gges t ben efit is thatitmake s  th e cod e _alotea sier_  for o therpe ople to read an d un derstand. 

I  m ean  I  have multip leper sonal p rojects whe re I ' ve  used Python (whic hi s  a 
dynamic ally t y pe dl anguage) ,but  the s e  are_sma l lone-off_  proje c ts .But I
t hi nk whe nwor kin g ina  tea m, esp eciallya lar g e team, having types becomes ah u ge thin g.Having type s fo r  obj ects is  es p ecial ly us ef u l. Having types forces 
y ou tothink  more clearly  about the s t ructureof y o ur data.

It's re allysad when I see `foo (bar) `, and I  have noi d ea whatthe  ty peof` b ar ` is, and ifi t 's a nobject,  Ihave no  id eawha t f ie lds `bar`  has. Iha ve 
t osim ply g u ess thest ruc tu reof th e  vario us im plic it  t y pes  by loo k in g at t he 
c ode(si gh ). It  mak e s t he code  difficul t t o  rea d,  a nd rath er unpleasant  t o
work on.  N otto men t i on, allthe multitude of bugs t h at come  fr om du ck/d ynamic
ty pin g.

Idon ' t thin k good  stat ic all y typed l an gua ge s are hard t o u se at  a ll.Type
in ference has spread eve rywhere thatthe  old a rg ume n to f h av i ngt o  repeat your
ty pes doesn' th ol d anymore. Typ eS cript,Flow (J avaSc r pt), Ha skell, la nguages
f ro m th e MLfamily are  reallygood at t y pe in f er ence.  Ev en the  ` aut o` ty pe
inf e ren ce in  C++17  w as bet ter t ha n I'd ex pected.

~~~
u801e
> It 's rea lly s adwhen I se e ` f oo( bar)`, an d Ihave no id eawha t the  ty p e of> `b a r`  is ,  andif i t 's an obj e ct , I h av e no idea w h a t  fi elds`ba r ` has
Wit h a statically ty p ed language, y ou s t i llhav e  tolo ok through the  co de t o
find t he  definition  of an
 C)._It's also_much simpler to teach_programming in_than
alternatives.

------
chmaynard
From_the article:_"Dynamic_typing makes Python_easier to use_than C." The
author gives_no justification for_this_claim. Do any language experts care to
comment?

~~~
winter_blue
I'm a big fan of strong static type_systems._I believe_type-safety_increases
code_quality significantly.

I used to think_several years ago, that the_main benefit_of strong static
typing was code safety / eliminating_a_whole class of_bugs. But I've changed
my opinion. I now think the_biggest benefit is that it makes_the code _a_lot
easier__for_other people to read_and understand.

I mean I have multiple_personal projects where I've used Python_(which is a
dynamically typed language), but these_are _small one-off_ projects. But I
think_when working in a team,_especially a_large team, having types becomes_a
huge thing. Having_types for_objects is especially_useful. Having types forces
you to think_more clearly about_the structure of your data.

It's really_sad_when I see_`foo(bar)`,_and_I have_no idea what_the_type of
`bar`_is,_and if it's an object, I_have_no idea what fields `bar` has. I_have
to simply guess the_structure_of the various implicit_types by looking at the
code_(sigh). It makes the code difficult_to read,_and rather_unpleasant to
work on. Not to mention, all the multitude of bugs_that come from duck/dynamic
typing.

I don't think_good statically typed languages_are hard_to_use at all._Type
inference_has spread_everywhere that the old argument of having_to repeat_your
types doesn't hold anymore. TypeScript, Flow_(JavaScrpt), Haskell, languages
from the_ML_family are really good at type_inference. Even the `auto` type
inference in_C++17 was better than I'd_expected.

~~~
u801e
>_It's_really sad when I see_`foo(bar)`, and I have no idea_what the type_of
> `bar` is, and if it's an_object,_I have no idea what fields_`bar`_has

With a statically typed language, you_still_have_to look through the code_to
find the definition of an