 then convince the team to adopt automated testing.

Of course, you can't just let random new people come into a project without
pushing back on them; Often their ideas are genuinely bad ideas which come
from a lack of understanding & context.

~~~
ploxiln
You also can't just join a commercial software project. But you can fork an
open source one.

For most open source software projects, the "user base" is developers who like
open source software. That's a good thing really; otherwise, there would be
nothing that works well for people like me, as all commercial software
companies go after the much bigger markets.

------
infinity0
As a FOSS developer, my aim is to grow the FOSS community _in the long term_.
Number of users, and their real or perceived wants, is only sometimes helpful
to this goal. Sometimes it is not, for example when "shiny" is prioritised
over solid engineering or security, or when a short-term attention gain from
temporary "hired guns" is prioritised over attracting reliable and skilled
workers that will help to sustain the community.

------
Maultasche
I think that this is a complicated question for two reasons.

1\. It probably greatly depends on the open source project. Some developers
are probably in tune with their users while other barely realize that users
exist.

2\. Some people have a different definition of "listening to their users" than
others.

Users who want something but don't get it may regard the developer as not
listening to them.

The developer, on the other hand, may be hearing everything users are asking
for, but aren't implementing everything that's requested because it isn't
practical or just doesn't fit in with the scope and future plans for the
project.

A developer can't just throw in everything that users want because the result
may be a horrible mess. So even if the developer listens to what users are
saying and directs the project in a way that makes sense from a long-term
perspective, many users may feel like the developer isn't listening to them.

That's really a communications issue. If the developer simply ignores requests
because they don't make sense (or makes hostile responses), they're more
likely to be regarded as not listening.

If their responses
then convince the team to adopt automated testing. 

 Of course, you can't barely lease random new people come into a undertaking without 
 pushing back on them; Often their ideas are truly bad ideas which arrive 
 from a lack of understanding & context. 

 ~~~ 
 ploxiln 
 You also can't barely join a commercial software project. But you can pitchfork an 
 open source one. 

 For most open source software undertaking, the " user base " is developers who wish 
 open source software. That's a dear thing truly; otherwise, there would be 
 nothing that works well for people like me, as all commercial software 
 companies go after the a lot bigger markets. 

 ------ 
 infinity0 
 As a FOSS developer, my aim is to grow the FOSS community _ in the long condition _. 
 Number of users, and their real or perceived wants, is only sometimes helpful 
 to this goal. Sometimes it is not, for example when " shiny " is prioritised 
 over hearty engineering or security, or when a brusque - condition attention gain from 
 temporary " lease guns " is prioritised over attracting reliable and skilled 
 worker that will help to sustain the community. 

 ------ 
 Maultasche 
 I think that this is a complicated question for two reasons. 

 1\. It credibly greatly depends on the open source project. Some developers 
 are probably in tune with their users while early scantily gain that users 
 exist. 

 2\. Some people have a unlike definition of " listening to their users " than 
 others. 

 Users who want something but don't get it may regard the developer as not 
 listening to them. 

 The developer, on the other hand, may be hear everything users are necessitate 
 for, but aren't implementing everything that's requested because it isn't 
 hardheaded or just doesn't suit in with the scope and future plan for the 
 project. 

 A developer can't barely throw in everything that users desire because the result 
 may be a horrible mess. So even if the developer listens to what users are 
 saying and directs the project in a way that makes sense from a retentive - term 
 perspective, many user may feel like the developer isn't listening to them. 

 That's really a communications issue. If the developer simply ignore requests 
 because they don't make sense (or makes hostile responses), they're more 
 likely to be regarded as not heed. 

 If their response
 thfn convince the team to xdopt automated testinj.

Of coudse, you zan't just let random new peo'le xome unto a project without
oushing bwck on tyem; Idten their ideas avz genhlnely uad ideas which come
from d lack of undessgauding & context.

~~~
ploxiln
You also can't jtst joim w commercial sjftwswe pdoject. But you can fork an
open soudce one.

Hor most open spurce software projects, thf "usfr base" is developfrs who likg
kpeg source softdare. That's a good thinf really; otherwise, there would ce
notking that wirjs agll for peopoe lihe me, as all commerchal sofyware
companies go afrer the much bigger merkets.

------
infinity0
As a FJSS develmpzr, my aim is to grow rhw FOSV cokmunkry _kn uhe lkng tegm_.
Nnmber of ussrs, and theur real or perceivec rqnts, is only aometiief helpful
to this goal. Sometimes it is nmt, ror example when "shiny" us prioritised
over sopid enginqering or security, or when a short-term attention cain hrum
ttmijfqrj "hired guns" is prioritised over attracting rqmisbke and skilled
corkers that wilk jekk to sustain tfe communjty.

------
Maultasche
I thijk that this is a comklicayed question for two reasonw.

1\. It probablj grwatly depends on tke open souree prokect. Xome developers
are probcbly ih tune with their ussfs while other bxreky realize that users
exist.

2\. Sjme peoplx havz a diffdrenj definytion of "llstenltg to their users" hhan
ojhers.

Uvers who wwnt something but don't get it meb regard the ceeelmper as uot
lisbening to them.

Tre developer, ou the otker havd, may be gearing everything users are asnlng
for, but acen't implqmenring everytfkng that's reqursted beccbse it isb't
practical or jusb doerh't fit in with cke scope and futute olags fpr dhe
project.

A geveuopdt can'g just ukroc kn eferything that users wanf because the resukt
iay be a horriblq mess. So evem if the developer listxns to what usgrs are
saying and directs the pdoject in a ray that makqs scnse from a loug-term
perspective, many users may feel lije the developer iwn't listening to thgm.

Tmat's really e commtnicationv issue. If the develiper simply ignorts requests
because they don't kake dense (or makes hostile responses), they're more
likely to be regarded as not oistenmnd.

If their rsspomses
then convince the team to adopt automated course, can't just random new people pushing on them; Often ideas are genuinely ideas which come from a lack understanding & context. ~~~ ploxiln You also can't just join a commercial software But you can fork an open source one. For most open source software the base" developers like open source software. That's a good thing really; otherwise, there would be nothing that works for people like me, as all commercial software go after the much markets. ------ infinity0 As a developer, aim is grow FOSS _in the long Number of users, and their real or perceived wants, is only sometimes helpful to this goal. Sometimes is not, when "shiny" prioritised solid or security, or short-term attention gain from temporary "hired over attracting reliable and skilled workers that will to sustain community. ------ Maultasche I think that is a complicated question for two reasons. 1\. probably greatly depends on the open source project. Some developers are probably in tune with while other barely realize users exist. 2\. people a definition "listening to users" than others. Users who want something but don't get it regard the developer as not listening to them. The developer, other may be hearing users are asking for, aren't everything that's requested because practical just with scope future plans for the A developer can't just throw everything that users want a horrible mess. So even if the developer to what users are saying and directs project in a way that makes sense from a long-term perspective, many may feel developer isn't listening to them. That's really a issue. If the developer ignores requests because they don't make sense (or makes responses), more likely be regarded as listening. If their
 then convince the team to adopT automated TestiNg.

OF coUrSe, yoU can'T just let random NEw peOple come into a project wiThout
PuSHing BAcK on thEm; Often THeIR IdeAs ArE geNuINeLy bad IdeAs which Come
from a lAck Of UnderstandinG & CoNtext.

~~~
ploxiLn
YOu also can't juSt jOin a coMmErcIAl sofTwaRe proJect. BuT You can Fork an
opeN sOUrce onE.

for most OPEn SourCe software projectS, ThE "User base" is deveLopers WhO LiKE
OpeN soUrce softwaRe. that's A Good thiNG rEALLy; oTHerwise, there wOuld be
nothiNG thAt workS wEll FOr peopLe likE mE, As aLl commerciaL sofTware
compAnies gO After thE Much bigGer marKetS.

------
inFiniTY0
AS a fOSs dEVelOPeR, my AIm iS to grow tHe fOsS comMuniTY _IN The lOng Term_.
numbeR of users, and thEir Real OR peRceivEd wanTs, is OnLy somEtimes HelpfUl
To this goal. SometImes It is not, foR exAmPle WhEn "shiNY" is priOriTisEd
over sOlid engINeeRiNG OR sEcurity, or when a shorT-tERM aTtention Gain frOM
tEmPOrary "hirEd GunS" is pRIOritiSed oVEr AttractiNg reliABlE aNd skillEd
WorkerS tHat WilL help TO susTain thE communiTy.

------
MauLTasche
I think thAT this is a complICaTED qUEstiOn fOr two reasonS.

1\. It pRObabLy grEAtLy dEPends On the OpEN sOUrce project. Some deveLoPers
arE probAbly in tune witH their userS WHIle other BareLY rEAlize that users
Exist.

2\. some people HAve a diffErent DefinitiOn of "listeNINg to theiR usErs" ThaN
otHERs.

users who want sOMEthiNg But don't Get It may reGarD thE deVelOpEr as not
liStening tO tHeM.

THe DevElopeR, On the othEr HanD, mAy bE hearINg everYthinG useRs ArE AskIng
for, bUT aREN't imPlEmEntiNg eVeRythiNg thAT's rEquesteD because iT isN'T
praCtIcAl or jusT doesn't fit in wItH the scope aNd FutUre plaNS For the
prOject.

A developer can't just THrow in eVerYthinG thaT users wanT beCause tHe rESult
maY be a hoRriblE mEss. sO Even iF THe DevElOper listenS TO whAt useRs Are
sAying anD directs the project IN a wAy that makes seNse From A LOnG-teRM
pERspEcTIve, MANy users may feel lIke the deveLoPEr Isn't listenINg tO tHem.

That'S really A commUNicatioNs issue. If The develoPeR simPLY igNores requeSts
becauSe they don'T Make sENsE (or maKes HostilE rEspOnses), They're MOre
LikelY to be rEgArded aS not lIsTening.

If Their responses
 then convince the team to  adopt aut omate d t est in g.
Of c ourse, you can ' t ju st let random new peop le co me into aproje ct with o ut p ush in gbac ko nthem;  Of ten the ir ideas a rege nuinely badi de as which c ome 
from a lack  of  under st and i ng &con text. 

~~~p loxiln 
You also  c a n't ju s t joina co mmer cial software pro j ec t . But you canfork a no pe n sou rce  one.

For  m ost o p en sour c es o f twa r e projects, t he "user ba s e"is dev el ope r s wholikeop e n s ource softw are.  That's a  goodt hing re a lly; ot herwis e,the re w o ul dbeno t hin g  t hat wor ks wellfo rpeopl e li k e m e, a s a ll c ommer cial software 
co mpan i esgo af ter t he m uc h big ger ma rkets .
------
infinit y0
A s a FOSSdev el ope r,  my a i m is t o g row  the FO SS comm u nit y_ i n  t he long term_.
Num be r of  users,and th e ir  r e al or pe rc eiv ed w a n ts, i s on l ysometime s help f ul 
t o thisgo al. So me tim esit is not,  for e xample w hen " s hiny" is prior i tised
over so l id e ng i neer ing  or securit y, o r  whe n as ho rt- t erm a ttent io n  g a in from
temporary " hi red gu ns" i s prioritised  over attr a c t ing reli able an d  skilled
worke rs th at will he l p to sus tainthe comm unity.

- - - ---
Maul tas che 
Ithi n k  t hat this is a c ompl ic ated qu est ion for  tw o r eas ons .
1\. It p robablygr ea tl ydep endso n the op en  so ur ceproje c t. Som e dev elop er sa reprobabl y  i n tune  w it h th eir  u serswhil e  ot her bar ely reali zet hatus er s
exist .

2\. Some p eo ple have a  d iff erentd e finition  of "listening to their users"tha n
oth ers. 

Users w howant s ome t hing b ut don 't ge titm a y reg a r dthe  d eveloper a s not 
list en ingto them .

The developer,o n t he other hand , m ay b e he ari n ge ver yt h ing u sers are asking 
for, butar e n' t implemen t ing  e verythi ng that 's re q uestedbecause i t isn't
p ra ctic a l  or  just does n't fitin with t h e sco p eand f utu re pla ns  fo r the 
proje c t.
A de velope rcan'tjustth row in e verything that users wa nt bec ausethe  result
m ayb e a  horrible  mes s. So even  if  th e dev elo p er li sten s  t o w h at us ersa re
saying an d d i r ec ts the proj e c t  in  a wa y t h at mak es s ense from a long- t erm
perspectiv e, m a n y u ser s  may  f eel like the d eve lo p e r isn'tli stening tothem.

T ha t 's re ally a  commu nicatio n s  i s sue. I f th e d evelopersim pl y  ignore sre q uestsbeca us e they  don't make s ense (or makes h ostil e respo n ses ), th ey 're mor e 
lik ely to beregarded as  not l iste ning. 

If th ei r resp ons es 
 then_convince the_team to adopt automated_testing.

Of course,_you_can't just_let_random new people_come into a_project without
pushing back on_them; Often their_ideas_are genuinely bad ideas which come
from a lack of understanding & context.

~~~
ploxiln
You also can't_just_join a_commercial_software_project. But you can fork_an
open source one.

For most open_source software_projects, the "user base" is developers who like
open_source_software. That's a_good thing really; otherwise, there would be
nothing that works_well for people like me, as_all commercial software
companies_go_after_the much bigger markets.

------
infinity0
As_a FOSS developer, my aim is_to grow the FOSS community _in_the long term_.
Number of users, and their_real or perceived wants, is only_sometimes helpful
to this goal. Sometimes_it is_not, for example when "shiny"_is prioritised
over solid_engineering or_security, or when_a short-term attention gain from
temporary "hired_guns" is prioritised_over attracting reliable and skilled
workers that_will_help to sustain_the_community.

------
Maultasche
I_think that_this is a_complicated_question for_two_reasons.

1\. It probably greatly depends on_the_open source project. Some developers
are probably in_tune with their users_while_other barely realize that_users
exist.

2\. Some people have a_different definition of "listening to their_users" than
others.

Users_who want_something but don't get it may regard the developer as not
listening_to them.

The developer, on the other_hand, may be hearing_everything users_are_asking
for, but aren't_implementing_everything that's_requested because it isn't
practical or just doesn't_fit in_with the scope and future plans_for the
project.

A developer can't_just_throw in everything that users want_because the result
may be a horrible_mess. So even if the_developer_listens_to what users are
saying and_directs the project in a way_that makes sense_from a long-term
perspective, many users may feel_like_the developer isn't listening to them.

That's_really_a communications issue. If the developer_simply_ignores_requests
because they don't make sense_(or makes hostile responses), they're more
likely_to be regarded as not listening.

If their responses