1 / 33

Analyzing the Eclipse API Usage: Putting the Developer in the Loop

Analyzing the Eclipse API Usage: Putting the Developer in the Loop. John Businge , Alexander Serebrenik , Mark van den Brand. Introduction. Software engineering researchers obtaining convincing evidence. Introduction. Few examples of convincing evidence.

anais
Download Presentation

Analyzing the Eclipse API Usage: Putting the Developer in the Loop

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Analyzing the Eclipse API Usage: Putting the Developer in the Loop John Businge, Alexander Serebrenik, Mark van den Brand

  2. Introduction Software engineering researchers obtaining convincing evidence Software Engineering and Technology (SET)

  3. Introduction Few examples of convincing evidence Software engineering researchers obtaining convincing evidence Software Engineering and Technology (SET)

  4. Introduction Few examples of convincing evidence Software engineering researchers obtaining convincing evidence Researchers generate evidence about A, C, Dand E yet developers care about B Software Engineering and Technology (SET)

  5. Introduction Few examples of convincing evidence Software engineering researchers obtaining convincing evidence Include developer in the loop Researchers generate evidence about A, C, Dand E yet developers care about B Software Engineering and Technology (SET)

  6. Terms used Eclipse Framework Eclipse Third-party Plug-ins (ETPs) P1 P2 P3 P4 Software Engineering and Technology (SET)

  7. Terms used • Eclipse non-APIs (“bad”) • “internal” • unstable, • discouraged, • unsupported • Eclipse APIs(“good”) • no “internal” • stable, • supported Eclipse Framework Eclipse Third-party Plug-ins (ETPs) P1 P2 P3 P4 • P3 – good ETPs • P1, P2 and P4 – bad ETPs Software Engineering and Technology (SET)

  8. Terms used Embryonic interfaces • Eclipse provisional API guidelines – document provided by Eclipse describing the different interfaces Software Engineering and Technology (SET)

  9. Terms used Battle-headed interfaces Embryonic interfaces • Eclipse provisional API guidelines – document provided by Eclipse describing the different interfaces Software Engineering and Technology (SET)

  10. Motivation of our study • Our previous studies aboutEclipse API Usage werebased on source code analysis. • Ourobservations: • 44% of ETPs on SourceForge use bad interfaces. • bad ETPsare largerthan good ETPs. • Good interfaces are indeedvery stable in newframework releases. • Bad interfaces are indeedunstable in new framework releases. Software Engineering and Technology (SET)

  11. Motivation of our study Include developer in the loop Omitting developer in the loop in previous studies Whybad ETPs are larger than good ETPs???? Why developers use bad interfaces???? Software Engineering and Technology (SET)

  12. Survey to include developer in loop • Goal – obtain the state-of-practice Eclipse interface usage • Reasons for use of bad interfaces • Difference in characteristics of bad ETPs and good ETPs • Research questions RQ1: Can we observe some relationships in factors related to Eclipse interface usage in the survey? RQ2: What are the differences in characteristics between bad and good ETPs? RQ3: What are the differences in characteristics between proprietary and open-source ETPs? Software Engineering and Technology (SET)

  13. Survey to include developer in loop • Goal – obtain the state-of-practice Eclipse interface usage • Reasons for use of bad interfaces • Difference in characteristics of bad ETPs and good ETPs • Research questions RQ1: Can we observe some relationships in factors related to Eclipse interface usage in the survey? RQ2: What are the differences in characteristics between bad and good ETPs? RQ3: What are the differences in characteristics between proprietary and open-source ETPs? Software Engineering and Technology (SET)

  14. Survey factors of investigation Software Engineering and Technology (SET)

  15. Sample Questions in the survey • How many years of experience as an Eclipse product/solution developer do you have? • Are you aware of the “Eclipse Provisional API Guidelines”? • Do you use non-APIs? • If answer was “NO” in (iii). Do you deliberately avoid using Eclipse non-APIs? • Survey Response • 30 ETP developers fully answered the questionnaire. Software Engineering and Technology (SET)

  16. RQ2 and RQ3 - groups • RQ3 – Difference between proprietary and open-source ETPs RQ2 – Difference between good and bad ETPs Software Engineering and Technology (SET)

  17. RQ2 and RQ3 - groups The two groups of RQ2 and RQ3 can be compared using the 10 identified factors. Software Engineering and Technology (SET)

  18. Differences between bad and good ETPs – RQ2 Hypotheses: H0: Developers who use bad interfaces and those who do not use bad interfaces have the same average values on each of the identified factors. Ha: There is a difference on the average values of the identified factors between the developers that use and do not use bad interfaces. Software Engineering and Technology (SET)

  19. Differences between developers that use and those that do not use bad interfaces Software Engineering and Technology (SET)

  20. Differences between developers that use and those that do not use bad interfaces We reject H0 that Developers who use bad interfaces and those who do not use bad interfaces have the same average values on each of the identified factors Software Engineering and Technology (SET)

  21. How different are the two groups of developers? Wediscovered that developers that use bad interfaces have higher values on these factors compared to those that do not use bad interfaces Software Engineering and Technology (SET)

  22. How different are the two groups of developers? Previously unanswered question “Why bad ETPs are larger than good ETPs?” Human factors More experiences developers Larger ETP development teams Developersof bad ETPs Wediscovered that developers that use bad interfaces have higher values on these factors compared to those that do not use bad interfaces Software Engineering and Technology (SET)

  23. Differences between open-source and proprietary ETPs Motivation: Previous studies we only considered open-sourcesoftware potentially putting generalizability to proprietarysoftware in jeopardy. Hypotheses: H0: Developers of open-source and proprietary ETPs have the same average values on each of the identified factors. Ha: There is a difference on the average values of the identified factors between the developers of open-source and proprietaryETPs. Software Engineering and Technology (SET)

  24. How different are the two groups of open-source and proprietary developers? Software Engineering and Technology (SET)

  25. How different are the two groups of open-source and proprietary developers? We accept H0 that there is no difference between open-source and proprietary ETPsin terms of the factors investigated Software Engineering and Technology (SET)

  26. How different are the two groups of open-source and proprietary developers? Current findings clear our doubts on generalizability of our previous studies. Software Engineering and Technology (SET)

  27. Use of bad interfaces • Asked why developers deliberatelyavoid usingbad interfaces. • Answerers were related to, knowing/assuming that the bad interfacesare unstable. • Asked why developers deliberately use bad interfaces • No goodinterface with necessary functionality. • Avoid reinventing the wheel. • To expose these bad interfaces. • Old bad interfaces are unlikely to disappear Software Engineering and Technology (SET)

  28. Use of bad interfaces • Asked why developers deliberatelyavoid usingbad interfaces. • Answerers were related to, knowing/assuming that the bad interfacesare unstable. Less experienced developers • Asked why developers deliberately use bad interfaces • No goodinterface with necessary functionality. • Avoid reinventing the wheel. • To expose these bad interfaces. • Old bad interfaces are unlikely to disappear More experienced developers Software Engineering and Technology (SET)

  29. Conclusion Survey was conducted to understand why developers use bad interfaces. Software Engineering and Technology (SET)

  30. Conclusion Survey was conducted to understand why developers use bad interfaces. Less experienced developers Instability overshadows benefits Software Engineering and Technology (SET)

  31. Conclusion Survey was conducted to understand why developers use bad interfaces. More experienced developers Less experienced developers Instability overshadows benefits Enjoy benefits despite the instability Software Engineering and Technology (SET)

  32. Conclusion Survey was conducted to understand why developers use bad interfaces. More experienced developers Less experienced developers Instability overshadows benefits Enjoy benefits despite the instability Discovered that there is no difference between proprietary and open-source ETPs based on the factors we studied. Software Engineering and Technology (SET)

  33. Thank you for listening by Include developer in the loop Researchers should generate evidence about topicsdevelopers care about Software Engineering and Technology (SET) http://www.win.tue.nl/~jbusinge/CSMR13/

More Related