SurfClipse-- An IDE based context-aware Meta Search Engine (Tool Demo)
•Download as PPTX, PDF•
1 like•299 views
Despite various debugging supports of the existing IDEs for programming errors and exceptions, software developers often look at web for working solutions or any up-to-date information. Traditional web search does not consider thecontext of the problems that they search solutions for, and thus it often does not help much in problem solving. In this paper, we propose a context-aware meta search tool, SurfClipse, that analyzes an encountered exception andits context in the IDE, and recommends not only suitable search queries but also relevant web pages for the exception (and its context). The tool collects results from three popular search engines and a programming Q & A site against the exception in the IDE, refines the results for relevance against the context of the exception, and then ranks them before recommendation. It provides two working modes--interactive and proactive to meet the versatile needs of the developers, and one can browse the result pages using a customized embedded browser provided by the tool.
Recommended
More Related Content
Similar to SurfClipse-- An IDE based context-aware Meta Search Engine (Tool Demo)
Similar to SurfClipse-- An IDE based context-aware Meta Search Engine (Tool Demo) (20)
More from Masud Rahman
More from Masud Rahman (20)
Recently uploaded
Recently uploaded (20)
SurfClipse-- An IDE based context-aware Meta Search Engine (Tool Demo)
- 1. SURFCLIPSE: CONTEXT-AWARE META SEARCH IN THE IDE Mohammad Masudur Rahman, Chanhcal K. Roy Department of Computer Science University of Saskatchewan International Conference on Software Maintenance and Evolution (ICSME 2014), Victoria, Canada
- 3. EXCEPTION DEBUGGING 3 Not a helpful message for understanding or solving the exception SoftwareResearchLab,UofS Web search!!
- 4. SOLVING EXCEPTION (STEP I: QUERY SELECTION) 4 Selection of traditional search query Switching to web browser for web search SoftwareResearchLab,UofS This query may not be sufficient enough for most of the exceptions
- 5. SOLVING EXCEPTION (STEP II: WEB SEARCH) 5 The browser does not know the context (i.e., details) of the exception. Not much helpful ranking Hundreds of search results Forces the developer to switch back and forth between IDE and browser. Trial and error in searching SoftwareResearchLab,UofS Switching is often distracting
- 6. SURFCLIPSE: IDE-BASED CONTEXT-AWARE META SEARCH ENGINE 6
- 7. TECHNICAL DETAILS & PROGRAMMING CONTEXT OF AN EXCEPTION 7 Programming context (i.e., context code) Error message Stack trace 1 2 3 SoftwareResearchLab,UofS
- 8. PROPOSED IDE-BASED META SEARCH MODEL Start Results Web page 8 SoftwareResearchLab,UofS
- 9. PROPOSED IDE-BASED META SEARCH MODEL Distinguished Features (5) IDE-Based solution Web search, search result and web browsing all from IDE No context-switching needed Meta search engine Captures data from multiple search engines Also applies custom ranking techniques Context-Aware search Uses stack traces information Uses context-code (surroundings of exception locations) Software As A Service (SAAS) Search is provided as a web service, and can be leveraged by an IDE. http://srlabg53-2.usask.ca/wssurfclipse/ 9 SoftwareResearchLab,UofS
- 10. PROPOSED IDE-BASED META SEARCH MODEL Two Working Modes Proactive Mode Auto-detects the occurrence of an exception Initiates search for exception by client itself Aligned with Cordeiro et al. (RSSE’ 2012) & Ponzanelli et al. (ICSE 2013) Interactive Mode Developer starts search using context menu Also facilitates keyword-based search Aligned with traditional web search within the IDE 10 SoftwareResearchLab,UofS
- 11. CONCLUSION & FUTURE WORK SurfClipse – context-aware meta search engine IDE-based complete web search solution Outperforms two relevant existing approaches More recall than three search engines with precision comparable to Google, the best performing engine. SurfClipse – DOM-based element extraction & topic modeling. Extensive parallelization to make result real time. Adaptation for other languages support exception handling: C#, PHP, Javascript and so on. 11
- 13. THANK YOU !! QUESTIONS? 13
- 14. REFERENCES [1] J. Cordeiro, B. Antunes, and P. Gomes. Context-based Recommendation to Support Problem Solving in Software Development. In Proc. RSSE, pages 85 –89, June 2012. [2] L. Ponzanelli, A. Bacchelli, and M. Lanza. Seahawk: Stack Overflow in the IDE. In Proc. ICSE, pages 1295–1298, 2013 [3] J. Brandt, P. J. Guo, J. Lewenstein, M. Dontcheva, and S. R. Klemmer. Two Studies of Opportunistic Programming: Interleaving Web Foraging, Learning, and Writing Code. In Proc. SIGCHI, pages 1589–1598, 2009. [4] S. Haiduc, J. Aponte, and A. Marcus. Supporting Program Comprehension with Source Code Summarization. In Proc. ICSE, pages 223–226, 2010 [5] M. M. Rahman, S. Yeasmin, and C. Roy. Towards a Context-Aware Meta Search Engine for IDE-Based Recommendation about Programming Errors and Exceptions. In Proc. CSMR-WCRE, pages 194–203, 2014. 14
Editor's Notes
- Programming exception is a very frequent and a common experience for software programmers or developers. Once an exception is encountered, the developer identifies the target source line that triggers the exception, and attempts to guess what makes the exception to be thrown. In order to dig deeper, the developer often debugs the source code.
- However, the debugging may not reveal the real cause behind the exception or may fail to provide any useful explanation which can be used for the solution of the exception. Thus at some point, the developer needs to look at web for solution or relevant information. Study shows that developers spend about 19% of their programming time in web surfing.
- One might be also interested to collect search query from the IDE. A traditional way for query selection is to copy the exception message, the first line of stack traces, and use it as the search query. - Sometimes, this query may return relevant results; however, there is a great chance that query would not be enough for most of the exceptions. - One may also attempt to develop a custom search query which often needs a deeper understanding about the cause or details of the exception, and it is also time-consuming. Moreover, the developer needs to switch to web browser from the IDE in order to perform the web search.
- In order to solve an exception using web search, they generally follow several steps. The first step is web search using search engines in the web browser. Here, they face several practical challenges: The web browser works in a different context and it does not know the detailed context of the encountered exceptions. Thus it returns results which might be inapplicable for the current programming problem and its context. For example, let us consider NullPointerException, this exception can trigger under hundreds of circumstances, and it is nearly impossible to return useful search results without knowing the detailed context of the exception. This search forces the developer to leave IDE and search in the browser, which is often distracting and time-consuming.
- SurfClipse: An IDE-based context-aware meta search engine.
- One of our important observations about traditional or ad-hoc approaches is that the technical details or the programming context of an encountered exception is not properly used each of which has great potential for problem solving. In this thesis, we exploit such information extensively, and attempt to help in different search related activities. This slide shows some examples. Once an unhandled exception encounters, IDE reports the stack trace. The first line of stack trace generally describes the technical error message. The programming code that triggers the exception is context, it is also called the context code. the technical details and the programming context of the errors and exceptions, and recommend different
- This is our proposed context-aware meta search model for IDE-based recommendation. It has tow modules: Client module (Eclipse plugin) Server module (Web service) Once the developer selects an exception from Error log or console view, the client module captures the error message, stack trace and the context code likely responsible for exception and sends to the computation (server) module. Upon getting the search request, the computation module sends the error message to multiple search engines. We use Google, Bing, Yahoo and the StackOverflow API to collect results and use them to develop the corpus. Once the corpus is developed, we apply our proposed metrics and algorithms to produce a result set that is relevant to the encountered exception. Then the results are sent to the client in the IDE panel. The developer can click each result and can browse page within their working environment.
- So, basically, we are providing four interesting and essential things in this model. A complete IDE-based web search solution Meta search from within the IDE Context-aware search SAAS based search solution, that can be leveraged by any IDE of any platform.
- The proposed model has two working modes–Proactive and Interactive. We design two modes to provide different needs of the developers and to meet demands of different problem solving situations. For example, the proactive mode provides recommendation without any effort. Once an exception occurs, the IDE detects the exception, develops the search query, collect other context details, and initiates the search. Once the results are available, the developer is notified of the results. In case of interactive mode, the developer can choose an error or exception encountered within the IDE, and can start the search through context-menu command. The IDE is responsible to extract the exception details and collect the results from the server. The model also provides a keyword-based interface where developer can perform keyword-based search. During keyword-based search, IDE also recommends a set of suitable keywords representing the current problem context (e.g., exception details).