 it the last 5%, I might just do it.

~~~
partisan
Keep in mind that the last 5% might mean a heck of a lot of time. There is
usually a reason why some things go unimplemented in open source projects and
the complexity and time required are usually high on the list.

~~~
kazinator
The last 5% is _my_ last 5%, not (necessarily) the project's 5%. I.e. the
difference between what is there and what I require, not between what is
there, and the project's goals.

------
Gratsby
If there's an IRC channel, mailing list, issue tracker, etc., I have a look at
it. Active communities are bonus points regardless of the bug list.

I also look at how friendly the project is to pull requests and outside
development. If a bug is important to me, I will spend the time to code a fix,
but if there's no hope for getting any changes made, that represents a large
risk to me. It's not a bad thing if the team in charge pushes back for higher
quality code, code style, or solutions practical for wider audiences.

If there's continuous integration in place with automated testing and static
code analysis that is fantastic. It's not a deal breaker if it's not, but
having it in place is a good sign.

Depending on the project, I may have a look at the source itself. I certainly
don't look the source of every application I use.

I have found that online recommendations in developer communities are not
always good. More than once I've tried out projects based on people
evangelizing them only to find out that they are pretty far from acceptable.

There are differences in how I judge things that will be customer facing or
that I'm going to have to support operationally. I'm a lot more critical at
that point, but my top 3 points are:

1\. Can I put it in a container. 2\. Are the developers committed to long term
support. 3\. Will they give me a t-shirt.

------
cweagans
I evaluate it the same way that I evaluate any other code that I'm bringing
into our project: is it robust, extensible, free of obvious errors, covered by
comprehensive unit/functional tests, etc.


it the last 5% , I might just do it. 

 ~~~ 
 partisan 
 observe in judgment that the last 5% might mean a heck of a lot of fourth dimension. There is 
 usually a cause why some thing go unimplemented in exposed source projects and 
 the complexity and prison term required are usually gamey on the tilt. 

 ~~~ 
 kazinator 
 The last 5% is _ my _ last 5% , not (inevitably) the project's 5% . i the 
 deviation between what is there and what I require, not between what is 
 there, and the project's goals. 

 ------ 
 Gratsby 
 If there's an IRC distribution channel, mailing list, issue tracker, etc. , I have a expression at 
 it. Active communities are bonus points regardless of the bug list. 

 I also front at how friendly the project is to pull requests and outside 
 development. If a bug is authoritative to me, I will spend the time to code a fix, 
 but if there's no hope for getting any changes made, that represents a large 
 risk to me. It's not a bad matter if the team in care pushes back for high 
 quality code, code style, or solutions practical for wide audiences. 

 If there's continuous integration in place with automated examination and static 
 code analysis that is fantastic. It's not a deal breaker if it's not, but 
 having it in place is a good sign. 

 Depending on the project, I may have a expression at the source itself. I surely 
 don't search the source of every application I use. 

 I have found that online recommendations in developer communities are not 
 constantly good. More than once I've tried out projects based on multitude 
 evangelizing them entirely to find out that they are pretty far from satisfactory. 

 There are differences in how I judge things that will be customer face or 
 that I'm going to take to support operationally. I'm a lot more critical at 
 that compass point, but my top 3 points are: 

 1\. Can I arrange it in a container. 2\. Are the developers committed to long term 
 support. 3\. Will they give me a t - shirt. 

 ------ 
 cweagans 
 I evaluate it the same manner that I evaluate any other code that I'm bring 
 into our project: is it robust, extensible, free of obvious errors, covered by 
 comprehensive whole / functional tests, etc.
 it the last 5%, I might just ao it.

~~~
partisan
Kegp in miid that the lasg 5% might mean a heck of a lov of time. There is
usually a rearon why slme thints gi unimplemeifed in open skmrce 'rijects and
the gomplexity dnd time requisea cre usually high on the list.

~~~
kazinatow
The laxt 5% is _my_ last 5%, got (mqcesaarily) the project's 5%. I.e. the
differehce betxeen what is thrre and what I require, not betaeen what is
there, wnd the prohect'f goals.

------
Gratsbh
If there's an IRC chanhel, mailing list, issue tracker, dtc., I have a loik at
lj. Active comnunitpes are bonus points segardlrss of the bug livt.

I also look at how frixndly the project is to pull sesuests and outsidw
dwvelokment. If x bue ia mmpkrtant to me, I will spend the rime to code a fix,
bit pg there's no gope fjr getting any changes made, that represenus a marge
risk to me. It's not a bad thing if the tgam in chawge pushes back for higher
quality code, code style, or skuutnins pfqchical for wider audiences.

If there's continuous jnueggation in place wlth automated testonh sgd static
code analysis that is fantastic. It's noj a deql breakew if it's not, but
having it in plqce is a goob sugn.

Depending on thz project, I oay nave s look at the source itrelf. I certainlj
don't looi the source of exerj ap[lication I use.

I have founq that onoine recommdndajions ig developeg communities are not
alwwys glog. More thaj once I've tried out projects bexed on peoplg
evdngvlizing tkem onky to find oue that they arg pretty yar frum acceptagle.

Therx are differqnces in how H judge thingv that wyll ve cystomer wacing or
that O'm going no havw to support operabionaumy. I'm a lot morz xritical at
that poknt, blt ky dop 3 points dre:

1\. Zan O put it in a coktakner. 2\. Are the developers comjitted to long terk
smpport. 3\. Wull they give me a t-snirt.

------
cweagans
I evalkate mt the same wai that I evaluate any other cods that I'm brlnging
into ouw priject: is it xobust, extensible, free of obvious errors, covered by
comprehwnsive unit/functioncl tests, etc.


it the last 5%, I might just ~~~ Keep in that the last of lot of time. is usually a why some things go unimplemented in source projects and the complexity and time required are usually high on the ~~~ kazinator The last 5% is _my_ last 5%, not (necessarily) the project's I.e. difference what there and what I require, not between what is there, and the project's goals. ------ Gratsby there's an IRC channel, mailing list, issue tracker, I have a look it. Active communities are bonus regardless the bug I look how friendly the is to pull requests and outside development. If a bug is important to me, I will spend time to fix, but there's hope getting any changes represents a large risk to me. bad thing if the team in charge pushes for higher code, code style, or solutions practical wider audiences. If there's continuous integration in place automated testing and static code analysis that is fantastic. It's not a deal breaker if but having it in is a good Depending the I have a at the source itself. I certainly don't look the source of application I use. I have found that online recommendations in are always good. More once I've tried out based people evangelizing them only out they from There differences in how I things that will be customer or that I'm going I'm a lot more critical at that point, my top 3 points are: 1\. Can put it in a container. 2\. Are the developers committed to long support. 3\. give me a t-shirt. ------ cweagans I evaluate the same way that evaluate any other code that I'm bringing into our is robust, extensible, of obvious errors, by comprehensive unit/functional etc.
 it the last 5%, I might just do it.

~~~
paRtisan
Keep In minD thAt tHe Last 5% MighT mean a heck of a lOT of tIme. There is
usually a reasOn why SoME thiNGs Go uniMplemenTEd IN OpeN sOuRce PrOJeCts anD
thE compleXity and timE reQuIred are usualLY hIgh on the liSt.

~~~
kAzinator
The lAst 5% Is _my_ laSt 5%, Not (NEcessAriLy) the ProjecT'S 5%. I.e. the
DifferencE bETween wHAt is theRE AnD whaT I require, not betweEN wHAt is
there, and thE projeCt'S GoALS.

------
GrAtsBy
If there's An iRC chANnel, maiLInG LISt, iSSue tracker, etc., i have a look aT
It. ACtive cOmMunITies arE bonuS pOIntS regardless Of thE bug list.

I Also loOK at how fRIendly tHe projEct Is tO pulL ReQuEstS aND ouTSiDe
dEVelOpment. If A bUg Is impOrtaNT TO Me, I wIll SpenD the tIme to code a fix,
But If thERe's No hopE for gEttiNg Any chAnges mAde, thAt Represents a largE
risK to me. It's nOt a BaD thInG if thE Team in ChaRge Pushes bAck for hIGheR
qUALItY code, code style, or soLuTIOnS practicAl for wIDeR aUDiences.

IF tHerE's coNTInuouS intEGrAtion in pLace wiTH aUtOmated tEsTing anD sTatIc
cOde anALysiS that iS fantastIc. It's NOt a deal breaker IF it's not, but
havINg IT In PLace Is a Good sign.

DepEndiNG on tHe prOJeCt, I MAy havE a looK aT ThE Source itself. I certaiNlY
don't lOok thE source of everY applicatiON i Use.

I have FounD ThAT online recommeNdatiOns in develOPer commuNitieS are not
aLways good. mORe than onCe I'Ve tRieD ouT PRoJects based on pEOPle
eVaNgeliziNg tHem only To fInd Out ThaT tHey are preTty far frOm AcCePtAblE.

TherE Are diffeReNceS iN hoW I judGE thingS that Will Be CuSTomEr facinG Or
THAt I'm GoInG to hAve To SuppoRt opERatIonally. i'm a lot morE crITicaL aT
tHat poinT, but my top 3 poinTs Are:

1\. Can I put It In a ContaiNER. 2\. Are the dEvelopers committed to lonG Term
supPorT. 3\. Will They Give me a t-sHirT.

------
cweagAns
i EvaluaTe it thE same WaY thAT i evalUATe Any OtHer code thaT i'M brInginG
iNto oUr projeCt: is it robust, extensIBle, Free of obvious ErrOrs, cOVErEd bY
CoMPreHeNSivE UNit/functional teSts, etc.


 it the last 5%, I might j ust do it. 

~~~ 
pa rti sa n
Ke ep i n mind that th e  las t 5% might mean a heck  of a  l o t of ti me. T here is us u a lly  a  r eas on wh y som e t hings g o unimplem ent ed  in open sou r ce  projectsand 
the complex ity  and t im e r e quire d a re us uallyh igh on  the list .~~~
ka z inatorT h elast  5% is _my_ last5 %, not (necessari ly) th ep ro j e ct' s 5 %. I.e. th ediffe r ence be t we e n wha t  is there and  what I req u ire , notbe twe e n what  is
t he r e,and the pro ject 's goals. 

---- - -
Grats b y
If th ere'sanIRC  cha n ne l,  ma il i ngl is t,i ssu e tracke r,  e tc.,I ha v e a  loo k a t
it . Act ive communiti esareb onu s poi nts r egar dl ess o f thebug l is t.

I also look  athow frien dly  t hepr oject is topul l r equests  and ou t sid ed e v el opment. If a bug i si m po rtant to  me, I wi ll spend th etim e to c ode a  fix , 
b ut if th ere'sn oho pe forge ttingan y c han ges m a de,that r epresent s a l a rge
risk to me .  It's not a b a dt h in g  ifthe  team in ch arge push es b a ck  fo r  high er
qu al i ty code, code style, o rsoluti ons p ractical forwider audi e n c es.

Ifther e 's continuous int egrat ion in pla c e with a utoma ted test ing and s t a tic
code  an aly sis  th a t  i s fantastic.I t 's n ot  a deal  br eaker i f i t's  no t,bu t
havingit in pl ac eis  a  go od si g n.

Depe nd ing  o n t he pr o ject,I may  hav eal ook  at the so u r ce i ts el f. I  ce rt ainly 
don ' t l ook the  source o f e v eryap pl ication  I use.

I ha ve  found tha tonl ine re c o mmendati ons in developer commun i ties ar e n ot
al ways  good. Mo rethan o nce I've t ried o ut pr oj ect s based o npeo pl e
evangeli z i ngthemon ly t o findout that they arep ret ty far from a cce ptab l e .
Th e re are  d i ffe r e nces in how I j udge thing st ha t will bec ust om er faci ng or
t hat I ' m going  to haveto suppor toper a t ion ally. I'ma lot mo re critic a l att ha t poi nt,  but m ytop  3 po ints a r e:
1\.Can Ipu t it i n a c on tainer.2\. Are the developerscommit ted t o l ong termsup p ort . 3\. Wil l th ey give me  at-s hirt. 

- - ----cwea g an s
I evalu atei t the sam e  w ayt h at  I evaluate a n y o thercod e  thatI'mbringing
into our project: is it  rob u s t,ext e nsib le , free of obvi ous  e r r ors, cov er ed by
compr ehensive  u n it/fu nction al tes ts, etc . 

 it_the last_5%, I might just_do it.

~~~
partisan
Keep_in_mind that_the_last 5% might_mean a heck_of a lot of_time. There is
usually_a_reason why some things go unimplemented in open source projects and
the complexity and time_required_are usually_high_on_the list.

~~~
kazinator
The last 5% is__my_ last 5%, not (necessarily)_the project's_5%. I.e. the
difference between what is there and_what_I require, not_between what is
there, and the project's goals.

------
Gratsby
If there's an_IRC channel, mailing list, issue tracker,_etc., I have_a_look_at
it. Active communities are_bonus points regardless of the bug_list.

I also look at how friendly_the project is to pull requests and_outside
development. If a bug is important_to me, I will spend_the time_to code a fix,
but if_there's no hope_for getting_any changes made,_that represents a large
risk to me._It's not a_bad thing if the team in_charge_pushes back for_higher
quality_code,_code style,_or solutions practical_for_wider audiences.

If_there's_continuous integration in place with automated_testing_and static
code analysis that is fantastic. It's_not a deal breaker_if_it's not, but
having it_in place is a good_sign.

Depending on the project, I may_have a_look at_the source itself. I certainly
don't look the source of every application_I use.

I have found that online_recommendations in developer communities_are not
always_good._More than once_I've_tried out_projects based on people
evangelizing them only to_find out_that they are pretty far from_acceptable.

There are differences in_how_I judge things that will be_customer facing or
that I'm going to_have to support operationally. I'm_a_lot_more critical at
that point, but_my top 3 points are:

1\. Can_I put it_in a container. 2\. Are the developers_committed_to long term
support. 3\. Will they_give_me a t-shirt.

------
cweagans
I evaluate it the_same_way_that I evaluate any other_code that I'm bringing
into our project:_is it robust, extensible, free of obvious errors, covered_by
comprehensive unit/functional tests,_etc.

