This document proposes an approach called DOMpletion to assist web developers in writing DOM manipulating JavaScript code. It analyzes the DOM states and JavaScript code to generate code completion suggestions. DOM states are represented as DOM element locators which are compressed to detect patterns. Code analysis generates code paths and logs DOM API calls. Suggestions are produced from DOM and code analysis. An evaluation found the technique achieved up to 83% recall and 90% precision for suggestions with average generation time of 2.8 seconds, demonstrating its effectiveness.
Understand the basics: what reactive programming is, how it works why you should use it. Check how RXSwift library achieves FRP and a declarative way programming!
Ubiratan Soares - Software Engineer da Stone, fala sobre Kotlin : Advanced Tricks no Kotlin Community Summit 2018.
https://eventos.imasters.com.br/kotlinsummit/
Saiba mais em
Understand the basics: what reactive programming is, how it works why you should use it. Check how RXSwift library achieves FRP and a declarative way programming!
Ubiratan Soares - Software Engineer da Stone, fala sobre Kotlin : Advanced Tricks no Kotlin Community Summit 2018.
https://eventos.imasters.com.br/kotlinsummit/
Saiba mais em
Second iteration of my javascript talk.
Presented at PHP Day Italia 2009 on May 15th.
Slides refactored, cut down code examples and added some content about js abstractions and ecmascript 3.1.
See http://federico.galassi.net/2009/05/17/javascript-the-good-parts-talk/
Follow me on Twitter!
https://twitter.com/federicogalassi
[4developers] The saga pattern v3- Robert PankowieckiPROIDEA
As you build more advanced solutions, you may find that certain interactions in your system depend on more than one bounded context. Order, Inventory, Payments, Delivery. To deliver one feature often many sub-system are involved. But you want the modules to be isolated and independent. Yet something must coordinate their work and business processes. Welcome the choreographer - the Saga Pattern a.k.a. Process Manager. In my talk I would like to: describe the Saga Pattern. show how you can simply introduce it to legacy codebase using existing gems and... ActiveRecord :) describe a few examples of Saga that we have in our systems so the audience can see many places where it fits. convince everyone that it is not so hard
Wiktor Toporek: Pomimo tego że JavaScript mocno ewoluował na przestrzeni ostatnich lat, zakorzeniona w nim jego asynchroniczna natura wciąż może sprawiać problem programistom i to zarówno początkującym jak i tym zaawansowanym. W prezentacji przyjrzymy się jednemu z bohaterów programowania asynchronicznego jakim jest Promise, przeanalizujemy niektóre z pułapek oraz zastanowimy się również czy w pełni wykorzystujemy jego potencjał.
Spicy javascript: Create your first Chrome extension for web analytics QAAlban Gérôme
Adobe Launch has a monitoring hooks API that provides more details about the rules that passed or failed. That's a great excuse for writing a Chrome extension. This will benefit you even if you have no need or experience with Adobe Launch.
Second iteration of my javascript talk.
Presented at PHP Day Italia 2009 on May 15th.
Slides refactored, cut down code examples and added some content about js abstractions and ecmascript 3.1.
See http://federico.galassi.net/2009/05/17/javascript-the-good-parts-talk/
Follow me on Twitter!
https://twitter.com/federicogalassi
[4developers] The saga pattern v3- Robert PankowieckiPROIDEA
As you build more advanced solutions, you may find that certain interactions in your system depend on more than one bounded context. Order, Inventory, Payments, Delivery. To deliver one feature often many sub-system are involved. But you want the modules to be isolated and independent. Yet something must coordinate their work and business processes. Welcome the choreographer - the Saga Pattern a.k.a. Process Manager. In my talk I would like to: describe the Saga Pattern. show how you can simply introduce it to legacy codebase using existing gems and... ActiveRecord :) describe a few examples of Saga that we have in our systems so the audience can see many places where it fits. convince everyone that it is not so hard
Wiktor Toporek: Pomimo tego że JavaScript mocno ewoluował na przestrzeni ostatnich lat, zakorzeniona w nim jego asynchroniczna natura wciąż może sprawiać problem programistom i to zarówno początkującym jak i tym zaawansowanym. W prezentacji przyjrzymy się jednemu z bohaterów programowania asynchronicznego jakim jest Promise, przeanalizujemy niektóre z pułapek oraz zastanowimy się również czy w pełni wykorzystujemy jego potencjał.
Spicy javascript: Create your first Chrome extension for web analytics QAAlban Gérôme
Adobe Launch has a monitoring hooks API that provides more details about the rules that passed or failed. That's a great excuse for writing a Chrome extension. This will benefit you even if you have no need or experience with Adobe Launch.
A work-in-progress talk on an academic perspective of Model-View-Update (the Elm architecture), including a work-in-progress formal semantics, and extensions to include distributed session types.
Globus Compute wth IRI Workflows - GlobusWorld 2024Globus
As part of the DOE Integrated Research Infrastructure (IRI) program, NERSC at Lawrence Berkeley National Lab and ALCF at Argonne National Lab are working closely with General Atomics on accelerating the computing requirements of the DIII-D experiment. As part of the work the team is investigating ways to speedup the time to solution for many different parts of the DIII-D workflow including how they run jobs on HPC systems. One of these routes is looking at Globus Compute as a way to replace the current method for managing tasks and we describe a brief proof of concept showing how Globus Compute could help to schedule jobs and be a tool to connect compute at different facilities.
We describe the deployment and use of Globus Compute for remote computation. This content is aimed at researchers who wish to compute on remote resources using a unified programming interface, as well as system administrators who will deploy and operate Globus Compute services on their research computing infrastructure.
Launch Your Streaming Platforms in MinutesRoshan Dwivedi
The claim of launching a streaming platform in minutes might be a bit of an exaggeration, but there are services that can significantly streamline the process. Here's a breakdown:
Pros of Speedy Streaming Platform Launch Services:
No coding required: These services often use drag-and-drop interfaces or pre-built templates, eliminating the need for programming knowledge.
Faster setup: Compared to building from scratch, these platforms can get you up and running much quicker.
All-in-one solutions: Many services offer features like content management systems (CMS), video players, and monetization tools, reducing the need for multiple integrations.
Things to Consider:
Limited customization: These platforms may offer less flexibility in design and functionality compared to custom-built solutions.
Scalability: As your audience grows, you might need to upgrade to a more robust platform or encounter limitations with the "quick launch" option.
Features: Carefully evaluate which features are included and if they meet your specific needs (e.g., live streaming, subscription options).
Examples of Services for Launching Streaming Platforms:
Muvi [muvi com]
Uscreen [usencreen tv]
Alternatives to Consider:
Existing Streaming platforms: Platforms like YouTube or Twitch might be suitable for basic streaming needs, though monetization options might be limited.
Custom Development: While more time-consuming, custom development offers the most control and flexibility for your platform.
Overall, launching a streaming platform in minutes might not be entirely realistic, but these services can significantly speed up the process compared to building from scratch. Carefully consider your needs and budget when choosing the best option for you.
Globus Connect Server Deep Dive - GlobusWorld 2024Globus
We explore the Globus Connect Server (GCS) architecture and experiment with advanced configuration options and use cases. This content is targeted at system administrators who are familiar with GCS and currently operate—or are planning to operate—broader deployments at their institution.
Developing Distributed High-performance Computing Capabilities of an Open Sci...Globus
COVID-19 had an unprecedented impact on scientific collaboration. The pandemic and its broad response from the scientific community has forged new relationships among public health practitioners, mathematical modelers, and scientific computing specialists, while revealing critical gaps in exploiting advanced computing systems to support urgent decision making. Informed by our team’s work in applying high-performance computing in support of public health decision makers during the COVID-19 pandemic, we present how Globus technologies are enabling the development of an open science platform for robust epidemic analysis, with the goal of collaborative, secure, distributed, on-demand, and fast time-to-solution analyses to support public health.
Unleash Unlimited Potential with One-Time Purchase
BoxLang is more than just a language; it's a community. By choosing a Visionary License, you're not just investing in your success, you're actively contributing to the ongoing development and support of BoxLang.
Cyaniclab : Software Development Agency Portfolio.pdfCyanic lab
CyanicLab, an offshore custom software development company based in Sweden,India, Finland, is your go-to partner for startup development and innovative web design solutions. Our expert team specializes in crafting cutting-edge software tailored to meet the unique needs of startups and established enterprises alike. From conceptualization to execution, we offer comprehensive services including web and mobile app development, UI/UX design, and ongoing software maintenance. Ready to elevate your business? Contact CyanicLab today and let us propel your vision to success with our top-notch IT solutions.
Gamify Your Mind; The Secret Sauce to Delivering Success, Continuously Improv...Shahin Sheidaei
Games are powerful teaching tools, fostering hands-on engagement and fun. But they require careful consideration to succeed. Join me to explore factors in running and selecting games, ensuring they serve as effective teaching tools. Learn to maintain focus on learning objectives while playing, and how to measure the ROI of gaming in education. Discover strategies for pitching gaming to leadership. This session offers insights, tips, and examples for coaches, team leads, and enterprise leaders seeking to teach from simple to complex concepts.
Software Engineering, Software Consulting, Tech Lead.
Spring Boot, Spring Cloud, Spring Core, Spring JDBC, Spring Security,
Spring Transaction, Spring MVC,
Log4j, REST/SOAP WEB-SERVICES.
Innovating Inference - Remote Triggering of Large Language Models on HPC Clus...Globus
Large Language Models (LLMs) are currently the center of attention in the tech world, particularly for their potential to advance research. In this presentation, we'll explore a straightforward and effective method for quickly initiating inference runs on supercomputers using the vLLM tool with Globus Compute, specifically on the Polaris system at ALCF. We'll begin by briefly discussing the popularity and applications of LLMs in various fields. Following this, we will introduce the vLLM tool, and explain how it integrates with Globus Compute to efficiently manage LLM operations on Polaris. Attendees will learn the practical aspects of setting up and remotely triggering LLMs from local machines, focusing on ease of use and efficiency. This talk is ideal for researchers and practitioners looking to leverage the power of LLMs in their work, offering a clear guide to harnessing supercomputing resources for quick and effective LLM inference.
In 2015, I used to write extensions for Joomla, WordPress, phpBB3, etc and I ...Juraj Vysvader
In 2015, I used to write extensions for Joomla, WordPress, phpBB3, etc and I didn't get rich from it but it did have 63K downloads (powered possible tens of thousands of websites).
First Steps with Globus Compute Multi-User EndpointsGlobus
In this presentation we will share our experiences around getting started with the Globus Compute multi-user endpoint. Working with the Pharmacology group at the University of Auckland, we have previously written an application using Globus Compute that can offload computationally expensive steps in the researcher's workflows, which they wish to manage from their familiar Windows environments, onto the NeSI (New Zealand eScience Infrastructure) cluster. Some of the challenges we have encountered were that each researcher had to set up and manage their own single-user globus compute endpoint and that the workloads had varying resource requirements (CPUs, memory and wall time) between different runs. We hope that the multi-user endpoint will help to address these challenges and share an update on our progress here.
In software engineering, the right architecture is essential for robust, scalable platforms. Wix has undergone a pivotal shift from event sourcing to a CRUD-based model for its microservices. This talk will chart the course of this pivotal journey.
Event sourcing, which records state changes as immutable events, provided robust auditing and "time travel" debugging for Wix Stores' microservices. Despite its benefits, the complexity it introduced in state management slowed development. Wix responded by adopting a simpler, unified CRUD model. This talk will explore the challenges of event sourcing and the advantages of Wix's new "CRUD on steroids" approach, which streamlines API integration and domain event management while preserving data integrity and system resilience.
Participants will gain valuable insights into Wix's strategies for ensuring atomicity in database updates and event production, as well as caching, materialization, and performance optimization techniques within a distributed system.
Join us to discover how Wix has mastered the art of balancing simplicity and extensibility, and learn how the re-adoption of the modest CRUD has turbocharged their development velocity, resilience, and scalability in a high-growth environment.
Check out the webinar slides to learn more about how XfilesPro transforms Salesforce document management by leveraging its world-class applications. For more details, please connect with sales@xfilespro.com
If you want to watch the on-demand webinar, please click here: https://www.xfilespro.com/webinars/salesforce-document-management-2-0-smarter-faster-better/
Large Language Models and the End of ProgrammingMatt Welsh
Talk by Matt Welsh at Craft Conference 2024 on the impact that Large Language Models will have on the future of software development. In this talk, I discuss the ways in which LLMs will impact the software industry, from replacing human software developers with AI, to replacing conventional software with models that perform reasoning, computation, and problem-solving.
Code reviews are vital for ensuring good code quality. They serve as one of our last lines of defense against bugs and subpar code reaching production.
Yet, they often turn into annoying tasks riddled with frustration, hostility, unclear feedback and lack of standards. How can we improve this crucial process?
In this session we will cover:
- The Art of Effective Code Reviews
- Streamlining the Review Process
- Elevating Reviews with Automated Tools
By the end of this presentation, you'll have the knowledge on how to organize and improve your code review proces
1. DOMPLETION
DOM-Aware JavaScript Code Completion
An approach to assist the Web Developers in
writing DOM manipulating JavaScript code
Kartik Bajaj, Karthik Pattabiraman, Ali Mesbah
University of British Columbia
{kbajaj, karthikp, amesbah}@ece.ubc.ca 1
2. Running Example (JavaScript)
1. function add(a,b) {
2. return a + b;
3. }
4.
5. var input1 = 10;
6. var input2 = 20;
7. if(input1 != 0) {
8. var sum = add(input1,input2);
9. alert(sum);
10. } else {
11. var sum = input2;
12. alert(sum);
13. }
2
3. Document Object Model (DOM)
document.getElementsByTagName(“input”);
3
HTML
BODY
DIV
id=“container”
INPUT
class=“val1”
value=“10”
INPUT
class=“val2”
value=“20”
BUTTON
id=“add”
value=“Add”
SPAN
class=“result”
html=“Result:”
document.getElementsByClassName(“val1”);
document.getElementsByClassName(“val2”);
document.querySelector(“html body #container input”);
4. DOM JavaScript Interaction
1. function add(a,b) {
2. return a + b;
3. }
4.
5. var input1 = 10;
5’. var input1 = document.getElementsByClassName(“val1”)[0].value;
6. var input2 = 20;
6’. var input2 = document.getElementsByClassName(“val2”)[0].value;
7. if(input1 != 0) {
8. var sum= add(input1,input2);
9. alert(sum);
9’. var html = “<p id=‘true’> + add(input1,input2) + “</p>”;
9’’. document.getElementById(“result”).innerHTML += html;
10. } else {
11. var sum = input2;
12. alert(input2);
12’. var html += “<p id=‘false’>” + sum+ “</p>”;
12’’. document.getElementById(“result”).innerHTML += html;
13. }
4
5. Updated DOM State(s)
Input 21
DOM State 0 DOM State 1
5
true”
30”
HTML
BODY
DIV
id=“container”
INPUT
class=“val1”
value=“10”
INPUT
class=“val2”
value=“20”
BUTTON
id=“add”
value=“Add”
SPAN
class=“result”
html=“Result:”
P
id=“false”
html=“20”
20
2
7. Challenges
7
Is this class name correct?
1. function add(a,b) {
Does 2. return the element a + b;
exist in DOM?
3. }
4.
5. var input1 = document.getElementsByClassName(“val1”)[0].value;
6. var input2 = document.getElementsByClassName(“val2”)[0].value;
7. if(input1 != 0) {
8. var sum= add(input1,input2);
9. var html = “<p id=‘true’> + add(input1,input2) + “</p>”;
10. document.getElementById(“result”).innerHTML += html;
11. } else {
12. var sum = input2;
13. var html += “<p id=‘false’>” + sum+ “</p>”;
14. document.getElementById(“result”).innerHTML += html;
15. }
Does it have the property “value”?
What is the updated DOM structure?
8. Straw man Approach
Manually inspect the DOM
Develop, Execute, Repeat
Tedious and time consuming
8
9. Problem Statement
• JavaScript code is challenging to develop and
analyze
– Handling interactions between JS and DOM
[MSR’14][ESEM’13]
• Lack of tool support [ESEM’13]
– Instant feedback required
9
11. Proposed Solution
Analyze each DOM state and assist the
developer while writing JavaScript Code
BUT
Number of DOM states can be infinite!!!
11
12. Intuition
DOM states exhibit patterns
12
HTML
BODY
DIV
id=“container”
INPUT
class=“val1”
value=“10”
INPUT
class=“val2”
value=“20”
BUTTON
id=“add”
value=“Add”
SPAN
class=“result”
html=“Result:”
HTML
BODY
DIV
id=“container”
INPUT
class=“val1”
value=“10”
INPUT
class=“val2”
value=“20”
BUTTON
id=“add”
value=“Add”
SPAN
class=“result”
html=“Result:”
P
id=“true”
html=“30”
S 0 S 1
13. DOM Element Locators
13
BODY
DIV
id=“container”
INPUT
class=“val”
value=“10”
INPUT
class=“val”
value=“20”
BUTTON
id=“add”
value=“Add”
SPAN
class=“result”
html=“Result:”
html body div#container input.val1
html body div#container input.val2
html body div#container button#add
html body div#container span.result
html body div#container input.val1
html body div#container input.val2
html body div#container button#add
html body div#container span.result p#true
html body div#container input.val1
html body div#container input.val2
html body div#container button#add
html body div#container span.result p#false
HTML
p
id=“false”
true”
html=“30”
S 012
14. Compression Techniques
14
html body div#container input.val1
html body div#container input.val1.val2
html body div#container input.val2
html body div#container input.val{d}
html body div#container button#add
html body div#container span.result
html body div#container input.val1
html body div#container input.val2
html body div#container button #add
html body div#container span.result p#true
html body div#container span.result
p#true#flase
html body div#container input.val1
html body div#container input.val2
html body div#container button #add
Duplicates Removed
Similar IDs combined
Similar classes combined
15. DOM Analysis
• Manual
• Automatic
• Crawl available DOM states.
• Convert each DOM state to a list of DOM
Element Locators.
• Detect patterns in DOM Element Locators.
15
16. JavaScript Code Analysis
16
1. function add(a,b) {
2. return a + b;
3. }
4.
5. var input1 = document.getElementsByClassName(“val1”)[0].value;
6. var input2 = document.getElementsByClassName(“val2”)[0].value;
7. if(input1 != 0) {
8. var sum= add(input1,input2);
9. var html = “<p id=‘true’> + add(input1,input2) + “</p>”;
10. document.getElementById(“result”).innerHTML += html;
11. } else {
12. var sum = input2;
13. var html += “<p id=‘false’>” + sum+ “</p>”;
14. document.getElementById(“result”).innerHTML += html;
15. }
.....
if(condition) {
then-statements;
} else {
else-statements;
.....
HTML
BODY
.....
condition;
log true;
then-statements;
.....
.....
condition;
then-statements;
.....
.....
condition;
log false
else-statements;
.....
.....
condition;
else-statements;
.....
DIV
id=“container”
INPUT
class=“val1”
value=“10”
INPUT
class=“val2”
value=“20”
BUTTON
id=“add”
value=“Add”
SPAN
S0
class=“result”
html=“Result:”
17. HTML
BODY
DIV
id=“container”
INPUT
class=“val”
value=“10”
INPUT
class=“val”
value=“20”
BUTTON
id=“add”
value=“Add”
SPAN
class=“result”
html=“Result:”
p
id=“false”
html=“30”
HTML
BODY
DIV
id=“container”
INPUT
class=“val”
value=“10”
INPUT
class=“val”
value=“20”
BUTTON
id=“add”
value=“Add”
SPAN
class=“result”
html=“Result:”
p
id=“true”
html=“30”
Example
17
1. function add(a,b) {
2. return a + b;
3. }
4.
5. var input1 = document.getElementsByClassName(“val1”)[0].value;
6. var input2 = document.getElementsByClassName(“val2”)[0].value;
7. input1 != 0;
8. dompleteLog(“main”,true);
9. var sum= add(input1,input2);
10. var html = “<p id=‘true’> + add(input1,input2) + “</p>”;
11. document.getElementById(“result”).innerHTML += html;
1. function add(a,b) {
2. return a + b;
3. }
4.
5. var input1 = document.getElementsByClassName(“val1”)[0].value;
6. var input2 = document.getElementsByClassName(“val2”)[0].value;
7. input1 != 0;
8. dompleteLog(“main”,false);
9. var sum = input2;
10. var html += “<p id=‘false’>” + sum+ “</p>”;
11. document.getElementById(“result”).innerHTML += html;
S1
S2
18. Code Analysis
• Generate possible code paths
• Execute JavaScript code
• Intercept calls to DOM API
• Analyze Logs
18
23. Evaluation
RQ1: Do DOM element locators converge?
RQ2: How accurate are the code completion suggestions?
– Precision
– Recall
RQ3: What is the performance overhead incurred?
23
31. RQ3: Performance
DOM Analysis Phase
• Crawled each web application until DOM element
locators merge.
• Recorded time elapsed by the end of each state
Code Analysis Phase
• Recorded time taken to list the suggestions
31
32. RQ3: Results
• DOM Analysis
– 173 seconds (3 minutes approx.)
• Code Analysis
– Min time: 1 second
– Max time: 6 seconds
– Avg. time: 2.8 seconds
32
Incurred only once
33. User Study
• 9 Participants
Group A : Using DOMpletion
Group B : Without DOMpletion
• 4 Tasks to analyze the DOM JavaScript
interactions
103
268
Time (Seconds)
Group A Group B
97.50% 90.83%
47.50%
76.25%
Recall Precision
Group A Group B 33
34. Contributions
1. Discussed challenges behind DOM based code completion.
2. Fully automated code completion technique using static and
dynamic analysis of JavaScript code and DOM.
3. Implementation in an open source tool called DOMpletion.
4. Empirical evaluation to assess DOMpletion.
https://github.com/saltlab/dompletion
34
Up to 83 % Recall and 90% Precision
2.8 seconds average time
Editor's Notes
describe the meaning
approach to assist the web developers in writing JavaScript code that interacts with DOM
before we go further lets have a quick look at the running example which we follow throughout the presentation
The code looks simple.. however when writing code for web applications
the code needs to be modified to get input and redirect outputs to the web application..
For this javascript code, lets use this really simple calculator application..
Before we go futher lets have a quick look how this web application is represneted in the web browser and how does javascript code written by the programmer interacts with it..
each web application is represented in the form of Document Object Model tree i.e DOM tree
each node in the DOM tree corresponds to certain elements in the web application.
For example, in this case the two highlighted leaf nodes represent the two input elements.
In order for the web developer to interacts with these elements
The takeway from this slide is there are more than one ways for a developer to select DOM elements and developers need to precisely analyze the DOM before selecting the DOM element.
dom is highly dynamic and interleaves and evolves with javascript code
----- Meeting Notes (2014-09-10 13:19) -----
red part separate
code completions for interactions between JS and DOM
Loosely typed JS
Highly dynamic DOM
These approaches are static and mainly used for finding errors in the code
not for code-completion
I order to compare the dom states, we need to get rid of the irrelevant information and focus on what exactly matters to the developers..
long time to generate
why do we need to compress??
need to provide quick answer to the developers
simulate unseen dom states using the detected patterns
DOM Analysis Phase 1
In this phase, we crawl the web application. This crawling can be either automated based on the randomized crawler or the developer can crawl the web app manually, if the developer wants to focus on limited number of DOM states.
Next, for DOM state we create a list of DOM element locators. By DOM element locators we refer to the combination of tag names, class names and ids attached to each element along with the hierarchical information.
Next, we detect patterns among these DOM element locators. the basic intuition behind our work is that these DOM element locators tend to converge over the increasing number of DOM states and exhibit patterns that can be recognized. During the evaluation phase we validate this intuition.
The output of this phase looks like this
----- Meeting Notes (2014-09-08 16:54) -----
general algo read the paper
----- Meeting Notes (2014-09-10 13:19) -----
show DOM in the corner
To provide a brief overview of our approach, we require two inputs from the developer.
The 1st one being the URL of the web application for which the developer is writing the JavaScript Code. If the web application is not running the developer can also provide the HTML code as an input to the system.
The 2nd one is the JavaScript that the developer is writing.
The 1st phase of our approach begins in the background and does not require any specific instruction from the developer. It starts with the 1st DOM state, keep exploring next available DOM states and collecting information.
The 2nd phase starts when the developer hits the code completion key. The JavaScript code written till then is taken as an input and dynamically analyzed.
The outputs of 1st and 2nd phase are then compared to generate suggestions for the user.
----- Meeting Notes (2014-09-08 16:54) -----
comes later phase for summary
----- Meeting Notes (2014-09-10 13:19) -----
dnt animate
We have implemented DOMpletion as plugin for the Brackets IDE using its Live Development feature to analyze the DOM.
The Brackets IDE is built as a Desktop application using nodejs.
We use Esprima JavaScript parser built in JavaScript to parse the JavaScript code given as input.
Therefore, keeping our implementation of DOM-Aware code completion tool in JavaScript itself.
Evaluation
We cover three main points:
Convergence of DOM element locators, i.e the intuition we had for the DOM analysis phase.
Accuracy in terms of precision and recall for the proposed technique.
Performance overhead caused by DOMpletion
----- Meeting Notes (2014-09-10 13:19) -----
this applies to other web sites too
css selector tpo
----- Meeting Notes (2014-09-10 13:19) -----
show code demo to complete
hierarchical information definition
how far the suggestion is and make it a positive statement
say about no hierarchy too
related work graph
----- Meeting Notes (2014-09-10 13:19) -----
summary of results
show just email address