 them really aren't.

I personally think there's a lot of up-and-coming languages that are exploring
the space of how to get those nicer programming abstractions and programmer-
convenient code without paying anywhere near the runtime cost that the dynamic
scripting languages of today do; it's one of the more exciting developments I
see coming up. People complain a lot about code bloat and poor performance of
our code since right now we have to choose between "fairly inconvenient but
fast" and "convenient but slow and bloated". Patience! Better choices are
developing, but they're still young.

~~~
monkmartinez
Will you please share the languages you thunk are up and coming?

~~~
jerf
Go is an early entrant into this space, but I think part of the reason it is
early is also that it is less ambitious. But to answer the ever-present
question on HN about "why would anyone ever use this language?", something
modern, almost as easy to use as a scripting language [1], and almost as fast
as a compiled language, doesn't actually have a lot of contenders. (Old
fogeys... like me!... like to observe that if you drop modern you have some
things like Delphi that fit that slot, but they're all pretty much dead now,
and Go has good support for concurrency in the modern processor environment.)

In the "you probably can't convince your boss yet" category I'd recommend
Crystal ([https://crystal-lang.org/](https://crystal-lang.org/)) and Nim
([https://nim-lang.org/](https://nim-lang.org/)).

Given the programming landscape and the general direction of things lately, I
also bet there's a couple of serious contenders developing out there that
haven't even hit HN yet.

[1]: For at least a broad class of problems. Put Go head-to-head with a
problem someone would use NumPy for and Go will go down in flames in the ease-
of-use and line count department. However I use Go for a lot of networks
servers (not even necessarily Web servers, but network servers) and the line
count for these comes out maybe 20% larger than Python, and it doesn't take
much developer cognitive energy for those
them really aren't. 

 I personally think there's a lot of up - and - coming lyric that are explore 
 the space of how to get those nicer scheduling abstractions and programmer- 
 convenient code without paying anywhere near the runtime monetary value that the dynamic 
 scripting languages of today make; it's one of the more exciting developments I 
 see come up. People complain a fortune about code bloat and poor performance of 
 our code since right now we have to choose between " fairly inconvenient but 
 fast " and " commodious but slow and bloated ". Patience! Better choice are 
 developing, but they're still new. 

 ~~~ 
 monkmartinez 
 Will you please share the language you thunk are up and coming? 

 ~~~ 
 jerf 
 Go is an early entrant into this space, but I think part of the rationality it is 
 early is also that it is less ambitious. But to answer the ever - present 
 question on HN about " why would anyone ever use this language? ", something 
 modern, almost as easy to use as a scripting language [ 1 ], and almost as fast 
 as a compiled speech, doesn't actually have a lot of rival. (Old 
 fogeys... like me! ... like to note that if you shed modern you have some 
 thing like Delphi that fit that slot, but they're all pretty a lot dead now, 
 and Go has good support for concurrency in the modern processor environment .) 

 In the " you probably can't convince your boss so far " category I'd commend 
 Crystal ([ https://crystal-lang.org/](https://crystal-lang.org/) ) and Nim 
 ([ https://nim-lang.org/](https://nim-lang.org/) ). 

 give the programming landscape and the general direction of things lately, I 
 also bet there's a couple of serious rival developing out there that 
 haven't even shoot HN yet. 

 [ 1 ]: For at least a broad course of problems. Put Go head - to - head with a 
 problem someone would practice NumPy for and Go will go down in flames in the ease- 
 of - use and note count department. However I use run low for a lot of networks 
 servers (not even necessarily Web server, but network servers) and the line 
 count for these comes out maybe 20% larger than Python, and it doesn't take 
 much developer cognitive energy for those
 thfm really aren't.

I personauly think there's a lot of up-znd-comine languages that are exploriig
thw spaxe of how to get those nicer prlgrammint abwrractions ehd progvcmmer-
dlnveuixnt code withouj paying anyfhere near the rjncime cost that the dynamic
scripting janguagrs of today do; ij's ont os ths more exciting developments I
see doming lp. People complaim a lot about code bloat ajd plor performance of
lur code sibce wught now we fave to choose between "fairly inconvenient but
fast" ana "conrenient but soow dnd bloated". Pativnce! Better cmpices dre
devekoping, but then're svill young.

~~~
monkmartinez
Wiln you please share the langgayes you thunk are up qne comhng?

~~~
jarf
Gu is an eerlg entrwnt into this space, but U think part of the rqqson it is
earmy is wlfo that it is less ambitious. But to ansfer the ever-present
questiob on HN about "why woupd anyone ever use this language?", something
modern, almost as easy go bwe as q dcripting language [1], and almost as fast
as a coilikec language, doefn't actuallu jafg a lot of conjenders. (Ols
fogeys... like me!... line to ofservw that if you drop modern you have some
tyings like Dvlphu that fit that sllt, but they'xe all pretyy much dead now,
and Go kas gokd support vor concudfency in the moddrn psocessor environment.)

In the "you probebly ean't conxincg your foss yet" cwtegovf I'd recommend
Cryshal ([hjtps://crfstal-lang.ogg/](https://crystal-lang.org/)) and Nim
([htv's://nim-lang.org/](hjtpv://nik-lang.org/)).

Yiven bhe programming landscape and the geueral airection kf thinjs lately, I
ajso bet there'v a couple of serious conrendwrs devduoping out thete that
haneu't even hut HN yet.

[1]: For at lcast x broad class of priblems. Put Go hrad-go-hqaf xith w
[roblem somemne douuc use NumPy for cna Go will go down in flakes jn the ease-
of-use amd line coont deparement. However I use Go for a lou of nxtworkr
servrrs (not even necessarily Web servsrs, but nftwjrk servers) wnd bhe jine
count yor these comes out maybe 20% larger than Pbthon, and it doesn't takw
much developer coguiuive energy fpr thjse
them really aren't. I personally think there's of languages that exploring the space nicer abstractions and programmer- code without paying near the runtime cost that the scripting languages of today do; it's one of the more exciting developments I coming up. People complain a lot about code bloat and poor performance of code right we to choose between "fairly inconvenient but fast" and "convenient but slow and bloated". Patience! Better choices developing, but they're still young. ~~~ monkmartinez Will please share the languages thunk are up and coming? jerf is an entrant this but I think of the reason it is early is also that it is less ambitious. But to answer the question on "why would ever this something modern, almost to use as a scripting language as fast as a compiled language, doesn't actually a lot contenders. (Old fogeys... like me!... like observe that if you drop modern you have things like Delphi that fit that slot, but they're all pretty much dead now, and good support for concurrency the modern processor In "you can't your boss category I'd recommend Crystal ([https://crystal-lang.org/](https://crystal-lang.org/)) and Nim ([https://nim-lang.org/](https://nim-lang.org/)). Given the programming and the general direction of things lately, I also bet couple serious contenders developing there that haven't even HN [1]: For at least class problems. with problem would use NumPy for Go will go down in in the ease- of-use I use Go for a lot of networks (not even necessarily Web servers, but network and the line count for these comes out maybe 20% larger than and it much developer cognitive energy for those
 them really aren't.

I personallY think therE's a loT of Up-aNd-ComiNg laNguages that are EXploRing
the space of how to get Those NiCEr prOGrAmminG abstraCTiONS anD pRoGraMmER-
cOnvenIenT code wiThout payinG anYwHere near the rUNtIme cost thaT thE dynamic
scriPtiNg langUaGes OF todaY do; It's onE of the MOre excIting deveLoPMents I
SEe cominG UP. PEoplE complain a lot abouT CoDE bloat and poor pErformAnCE oF
OUr cOde Since right NoW we haVE to chooSE bETWEen "FAirly inconvenIent but
fast" ANd "cOnveniEnT buT Slow anD bloaTeD". patIence! Better ChoiCes are
devElopinG, But they'RE still yOung.

~~~
moNkmArtInez
wIlL yOu pLeASe sHArE thE LanGuages yoU tHuNk are Up anD COMIng?

~~~
jErf
go is An earLy entrant into ThiS spaCE, buT I thiNk parT of tHe ReasoN it is
eArly iS aLso that it is less AmbiTious. But tO anSwEr tHe Ever-pREsent
qUesTioN on HN abOut "why wOUld AnYONE eVer use this language?", SoMEThIng
moderN, almosT As EaSY to use as A sCriPtinG LAnguaGe [1], anD AlMost as faSt
as a cOMpIlEd languAgE, doesn'T aCtuAllY have A Lot oF conteNders. (Old
FogeyS... Like me!... like to obSErve that if you DRoP MOdERn yoU haVe some
thingS likE delpHi thAT fIt tHAt sloT, but tHeY'Re ALl pretty much dead now,
AnD Go has Good sUpport for concUrrency in tHE MOdern proCessOR eNVironment.)

In the "You prObably can't COnvince yOur boSs yet" catEgory I'd reCOMmend
CryStaL ([htTps://CrySTAl-Lang.org/](https://cRYStal-LaNg.org/)) anD NiM
([https://nIm-lAng.Org/](HttPs://Nim-lang.orG/)).

Given thE pRoGrAmMinG landSCape and tHe GenErAl dIrectIOn of thIngs lAtelY, I
AlSO beT there's A CoUPLe of SeRiOus cOntEnDers dEvelOPinG out theRe that
havEn't EVen hIt hN Yet.

[1]: For aT least a broad cLaSs of probleMs. put go head-TO-Head with A
problem someone would use nUmPy for And go wilL go dOwn in flamEs iN the eaSe-
oF-Use and Line coUnt dePaRtmENT. HoweVER I Use go For a lot of nETWorKs
serVeRs (noT even neCessarily Web serverS, But Network serverS) anD the LINe
CouNT fOR thEsE ComES Out maybe 20% larger tHan Python, aNd IT dOesn't take
mUCh dEvEloper cOgnitivE enerGY for thoSe
 them really aren't.

I pe rsonally t hinkthe re' sa lo t of  up-and-coming lang uages that are explori ng
th es pace of  howto gett ho s e  ni ce rpro gr a mm ing a bst raction s and prog ram me r-
convenien t  c ode withou t p aying anywhe renear t he  ru n timecos t tha t thed ynamic 
scriptin gl anguag e s of to d a ydo;it's one of the m o re exciting devel opment sI 
s e e  co min g up. Peop le  comp l ain a l o ta b o utc ode bloat and  poor perfo r man ce ofou r c o de sin ce ri gh t  no w we have t o ch oose betw een "f a irly in c onvenie nt but 
fa st"  and "c on ven ie n t b u tslo w  an d bloate d" .Patie nce! B e t tercho ices  aredeveloping, b utthey ' restill  youn g.
~~ ~
mon kmarti nez
W il l you please sh arethe langu age syou  t hunka re upand  co ming?
~~~
jer f 
Go  i s a nearly entrant into  t h i sspace, b ut I t h in kp art of t he  re ason i t isearl y  i s also t hat it is  l ess amb it ious.Bu t t o a nswer theever-p resent
q uesti o n on HN about" why would any o ne e ve r  use  th is language ?",s omet hing mo der n , alm ost a se as y  to use as a script in g lang uage[1], and almo st as fast a s  a compi ledl an g uage, doesn'tactua lly have a lot of c onten ders. (O ld
fogeys . . . like m e!. ..lik e t o ob serve that if y ou d ro p moder n y ou have  so methi ngs  l ike Delph i that f it  t ha tslo t, bu t  they're  a llpr ett y muc h  deadnow,andGo  h a s g ood sup p or t forco nc urre ncy  i n the  mod e rnprocess or enviro nme n t.)
I nthe "yo u probably ca n' t convince  y our  bossy e t" categ ory I'd recommend
Cryst a l ([htt ps: //cry stal -lang.org /]( https: //c r ystal- lang.o rg/))  a ndN i m
([h t t ps :// ni m-lang.org / ] (ht tps:/ /n im-l ang.org /)).

Given the pr o gra mming landsca peandt h egen e ra l  di re c tio n of things latel y, I
alsobe t  t here's a c o upl eof seri ous con tende r s devel oping out  there th at 
hav e n 'teven hit H N yet.
[1]: Fora t lea s ta bro adclassof  pr oblem s. Put Gohead- to-hea dwith a 
prob le m someon e would use NumPy for a nd Gowillgodown in f lam e s i n the eas e-
o f-use andlin e c ountdep a rtmen t. H o we ver I use  Gof or a loto fnet w o rk s
servers ( n o t  ev en ne ces s arilyWebservers, but netw o rk servers) an d th e lin e
c o untfo r these comesout  m a y be 20% l ar ger than Py thon, an di t doe sn't t ake
mu ch deve l o pe r  cogni tive  en ergy fortho se 
 them_really aren't.

I_personally think there's a_lot of_up-and-coming_languages that_are_exploring
the space of_how to get_those nicer programming abstractions_and programmer-
convenient code_without_paying anywhere near the runtime cost that the dynamic
scripting languages of today do; it's_one_of the_more_exciting_developments I
see coming up. People_complain a lot about code_bloat and_poor performance of
our code since right now we_have_to choose between_"fairly inconvenient but
fast" and "convenient but slow and bloated"._Patience! Better choices are
developing, but they're_still young.

~~~
monkmartinez
Will you_please_share_the languages you thunk_are up and coming?

~~~
jerf
Go is an_early entrant into this space, but_I think part of the reason it_is
early is also that it is_less ambitious. But to answer_the ever-present
question_on HN about "why would_anyone ever use_this language?",_something
modern, almost as_easy to use as a scripting_language [1], and_almost as fast
as a compiled language,_doesn't_actually have a_lot_of_contenders. (Old
fogeys..._like me!... like_to_observe that_if_you drop modern you have some
things_like_Delphi that fit that slot, but they're_all pretty much dead_now,
and_Go has good support_for concurrency in the modern_processor environment.)

In the "you probably can't_convince your_boss yet"_category I'd recommend
Crystal ([https://crystal-lang.org/](https://crystal-lang.org/)) and Nim
([https://nim-lang.org/](https://nim-lang.org/)).

Given the programming landscape and the_general direction of things lately, I
also_bet there's a couple_of serious_contenders_developing out there_that
haven't_even hit_HN yet.

[1]: For at least a broad_class of_problems. Put Go head-to-head with a
problem_someone would use NumPy_for_and Go will go down in_flames in the ease-
of-use and line_count department. However I use_Go_for_a lot of networks
servers (not_even necessarily Web servers, but network_servers) and the_line
count for these comes out maybe 20%_larger_than Python, and it doesn't take
much_developer_cognitive energy for those