Untitled / dleeftink

dleeftink

dennis is fine

Workspace

Public

Edited

Jan 29, 2023

{

let paragraph = htl.html``

paragraph.textContent ="online conversations are represented as threads, and the con-\nversation trees within these threads are important in under-\nstanding the behaviour of online users. Unfortunately, the\n"

return paragraph.textContent.split(/\n(?!$)/).map(d=>``+d+`\n`).join('')

}

//getWide({_:

getWide({d3,tree:false,query:('*'),filter:(k,c,p)=>c,depth:10, dist:false,format,mode:'BFS',cycles:true, leaves:null/*, meta: (v)=> ({time:performance.now()})*/})

//.map(d=>d.chain.map(d=>d.ext.time))

format = import('https://cdn.skypack.dev/xml-formatter@2.6.1?min').then(i=>i.default)

parse = acorn.parse

acorn = import('https://unpkg.com/acorn@8.8.2/dist/acorn.mjs?module')

JXON = (await import('https://cdn.skypack.dev/jxon@2.0.0-beta.5?min')).default

[...

createXML({_})

.querySelectorAll('*')].map(d=>d.outerHTML)[0]

testObj = ({a:{d:{left:1,top:2,width:3,e:[2,2,7,'s']}},e:[1,2,3,4],b:{f:{left:1,top:2,width:52,height:4}}})

[...temp[0].querySelectorAll('string[value^=SOME]')].map(d=>d.parentNode.outerHTML)[0]

target = Object.getOwnPropertyNames(d3.Voronoi.prototype).length

temp = locate({d3, mode:'BFS', depth: 10,filter:(k,c,p)=> (p.type == 'Object' || p.type == 'Array') && c.type=='String',cycles:true, leaves:null})[0].node.parentNode.out

function locate({ prefix = '@' , separator = '.' , mode = "BFS", depth = 5, cycles = false, top = 1024, iters = 1024, filter = (k,v,p)=> v , leaves = null, ... rest} = {}) {

let object = rest;

let entry, method, i = 0;

let inner = {};

let outer = [];

let stack = []; stack.push([[prefix],object]);

let prior = new Set();

let store = new Map();

let its = (filter);

let has = (prop) => Object.prototype.toString.call(prop);

let not = (prop, ...types) => !any(prop,...types) ;

let any = (prop, ...types) => types.some((type) => has(prop) === has(type));

let end = (prop) => leaves === null ? ~leaves : leaves ^ typeof prop === typeof {};

let get = (path) => path.slice(1).reduce((path,item)=> path && path[item] || null,

(object))

let see = (prop) => prop && any(prop, Object(), Array(), Function()) ? prop.prototype

? Object.entries(Object.getOwnPropertyDescriptors(prop.prototype))

.filter((d) => d[0] !== "constructor")

.map((d) => [d[0], d[1].value])

: Object.entries(prop) : [];

let pin = ({ key , item , path }= {}) => {

let sub = see(item);

let out = {

[ path.join(separator) ]: key,

name: key,

call: item?.name,

step: path.length,

type: typeof item === 'function' && /^class\s/.test(Function.prototype.toString.call(item))

? 'Class' : has(item).replace(/[\[\]]/g,'').split(' ')[1],

hash: '',//hashCode(item,2),

sign: hashCode(Object.fromEntries(sub.map(d=>[d[0],'']).sort()),2),

size: sub.length,

path: path.slice(1),

item

}

let node = document.createElement(out.type);

node.setAttribute('name', out.name);

if(out.call) { node.setAttribute('call', out.call) };

node.setAttribute('hash', out.hash);

node.setAttribute('step', out.step);

// if(out.hash !== out.sign) { node.setAttribute('sign', out.sign) };

node.setAttribute('size', out.size);

Object.defineProperty(node,'out',{

get: ()=>pretty(node.outerHTML)

}) ;

return {...out,node}

}

while (stack.length) {

let [path,current] = stack.pop();

switch (mode) {

case "BFS": entry = see(current), method = "unshift" ; break;

case "DFS": entry = see(current).reverse(), method = "push"; break;}

for ( let [key, item] of entry ) {

if ( prior.has(key) && !isFinite(key) && !cycles ||

( depth < path.length || outer.length > top -1 || i > iters ))

{ continue }; prior.add(key); i++;

let parentPath = [...path].join(separator);

let childsPath = [...path,key].join(separator);

let parent = store.get(parentPath) ?? pin({key:path.at(-1),item:get(path),path});

let child = pin({key,item,path});

parent.node.appendChild(child.node)

store.set(childsPath, child)

if ( item && any( item, Object(), Function(), Array()) )

{ Array.prototype[method].call(stack, [path.concat(key),item]) }

else if ( not(item,Symbol()))

{ child.node.setAttribute('value', item ); }

if ( its(key,child,parent) && end(item) )

{ outer.push({...child, parent});child.node.setAttribute('include',true); }

}

store.forEach((entry)=>!entry.node.getAttribute('include') ? entry.node.replaceWith(...entry.node.children) :

entry.node.removeAttribute('include'))

return outer

//mode == 'DFS' ? outer.sort((a,b)=> a.path.localeCompare( b.path) || a.name.localeCompare( b.name)) : outer //

}

dfs(testObj)

function dfs(obj, out = {}, prev = []) {

if(obj){

for (let [key, val] of Object.entries(obj)) {

let path = [...prev, key];

if (typeof val === "object" && prev.length < 3) {

out[key] = {};

dfs(val, out[key], path);

} else {

out[key] = val;

}

console.log(path.length,key,path)

}

} return out;

}

graph = ({a:[12,2,{y:3,z:{o1:{u:{r:cycle}}},e:{f:cycle}}],s:'!',b:{j:{k:null},x:1,o2:cycle,o3:cycle},c:[23,24,[25,26,undefined]]})

stringify(graph,2)//,(k,v)=> k == 'y' ? v : undefined)

fetch('https://cdn.skypack.dev/-/tufte-css@v1.7.2-g1wyqg4s9i8xXAct2gEy/dist=es2020,mode=raw/tufte.min.css')

highlighter = new Highlighter()

highlighter.cache.data

Highlighter = (await import('https://cdn.skypack.dev/web-highlighter@0.7.4?min')).default;

{

highlighter.on('selection:create', ({sources}) => {

sources = sources.map(hs => {

// save to backend

let flat = [...paragraphs.querySelectorAll(`*`)];

let last = flat.findIndex(el=> el.dataset.highlightId == hs.id);

let page = flat.slice(0,last).findLastIndex((el) => el.tagName == 'H2');

let h3 = flat.slice(0,last).findLastIndex((el) => el.tagName == 'H5');

let h2 = flat.slice(0,h3 > 0 ? h3 : last).findLastIndex((el) => el.tagName == 'H4');

let h1 = flat.slice(0,h2 > 0 ? h2 : last).findLastIndex((el) => el.tagName == 'H3');

let {text} = hs;

let out = {

p:flat[page]?.textContent,

h1:flat[h1]?.textContent,

h2:flat[h2]?.textContent,

h3:flat[h3]?.textContent,

ts: Date.now()

}

return {...hs,out}

})

highlighter.cache.save(sources)

});

}

// highlighter.run();

{

let range = new Range();

range.setStart(paragraphs.children[1].firstChild, 2);

range.setEnd(paragraphs.children[1].firstChild, 3);

console.log(range.toString()); // ample: italic and bol

// use this range for selection (explained later)

window.getSelection().addRange(range);

}

Type JavaScript, then Shift-Enter. Ctrl-space for more options. Arrow ↑/↓ to switch modes.

{ let start = 0,end = 0;

let spans = paragraphs.children[1].innerHTML.split(/\b/)

.map(d=> `${d}`)

paragraphs.children[1].innerHTML = spans.join('');

return paragraphs.children[1].outerHTML

}

{

//let clone = document.createElement('p');

// clone.innerHTML = paragraphs.children[1].innerHTML.replace(/([^\s]+)/g,"$1")

//return [...clone.querySelectorAll('span')].map((d,{x,y})=> ({x,y,d} = {x:1,y:2}))

}

{

var selection = window.getSelection();

selection.removeAllRanges();

var range = document.createRange();

range.setStart( paragraphs.querySelector(':nth-child(2)'), 0);

range.setEnd( paragraphs.querySelector(':nth-child(3)'), 1);

selection.addRange(range);

}

{

let selection = window.getSelection()

return [selection.anchorNode, selection.focusNode]

}

paragraphs = htl.html`<div class="ndfHFb-c4YZDc-cYSp0e-DARUcf-Df1ZY-bN97Pc-haAclf"><h2 class="ndfHFb-c4YZDc-cYSp0e-DARUcf-Df1ZY-tJHJj" tabindex="0">Page 1 of 8</h2>Reconstruction of Threaded Conversations

in Online Discussion Forums

Erik Aumayr and Jeffrey Chan and Conor Hayes

Digital Enterprise Research Institute

NUI Galway, Ireland

Email: {erik.aumayr, jkc.chan, conor.hayes}@deri.org

Abstract

Online discussion boards, or Internet forums, are a significant

part of the Internet. People use Internet forums to post ques-

tions, provide advice and participate in discussions. These

online conversations are represented as threads, and the con-

versation trees within these threads are important in under-

standing the behaviour of online users. Unfortunately, the

reply structures of these threads are generally not publicly

accessible or not maintained. Hence, in this paper, we in-

troduce an efficient and simple approach to reconstruct the

reply structure in threaded conversations. We contrast its ac-

curacy against three baseline algorithms, and show that our

algorithm can accurately recreate the in and out degree dis-

tributions of forum reply graphs built from the reconstructed

reply structures.

1 Introduction

Internet forums are an important part of the Web. Along

with Twitter, web logs and wikis, they provide a platform for

questions to be asked and answered, information to be dis-

seminated and public discussions on all types of topics. Ac-

cording to Internet Brands1, 11% of Internet traffic in 2009

consists of visits to online forums, showing forums are still

an integral part of the Web.

In forums, conversations are represented as sequences of

posts, or threads, where the posts reply to one or more earlier

posts. For example, Figure 1 shows a thread from the poker

forum on www.boards.ie. It consists of a sequence of posts

discussing how to become a Texas Hold’em poker dealer.

Links exist between posts if one is the reply of another.

The threaded nature of forums allows us to follow the con-

versations, and thus study interesting problems. For exam-

ple, users can be profiled and analysed based on their reply-

ing behaviour, which is extracted from the reply structure

of forums. In (Chan, Daly, and Hayes 2010), users were

profiled using this method, then grouped together into user

roles of common behaviour. The roles were then used to

decompose forums into percentage of users playing partic-

ular roles. Another sample application is in topic and trend

tracking (Allan 2002). By recovering the reply structure, we

can follow the actual conversation stream in threads, which

Copyright c 2011, Association for the Advancement of Artificial

http://www.internetbrands.com

might not be in the order the posts are posted. As it can be

seen, the reply structure of threads have many applications.

There are many forums and many datasets of forums on-

line. However, the reply structure of threads is not always

available. This can be due to the failure of the board system

to properly log them, it is not maintained by the providers, it

is not publicly available or even lost. Therefore in this paper,

we propose a new method to reconstruct the reply structure

of posts in forums.

Prior work in reconstructing the thread structure is limited

(Wang et al. 2008). They focus on either detecting ques-

tion and answers in forums (Cong et al. 2008), which is

only one type of thread in online forums, or only use con-

tent to reconstruct thread structure, which results in low ac-

curacy (Wang et al. 2008). We propose a new approach

to reconstructing thread structures. It uses a set of simple

features and a classifier (a decision tree) to reconstruct the

reply structure of threads. We evaluate the accuracy of the

algorithm against the existing and a baseline algorithm us-

ing traditional notions of precision and recall and the ability

of the algorithms to recreate the in and out degree distribu-

tions of reply graphs built from the reconstructed replying

structure. We also analyse how well the algorithms perform

in recreating the local in and out degrees and the clustering

coefficient for individual vertices in the reply graphs.

In summary, the contributions of this work are:

• Proposal of a classification approach to reconstruct reply

behaviours in threads, that uses content and non-content

features.

• Show that the algorithm can accurately recreate the in and

out degree distributions of the forum reply graphs that are

created from the reconstructed reply structures.

• Show that the difference in accuracy of our algorithm and

a baseline algorithm result in significant differences in the

local degree and clustering coefficient values of the reply

forum graphs.

The remainder of this paper is as follows. In Section 2

we describe related work, then we explain our approach to

reconstructing threaded conversations in Section 3. In the

next section, we present our evaluate and contrast the results

of the different approaches. Finally, Section 5 concludes this

paper and presents possible future work.

26

Proceedings of the Fifth International AAAI Conference on Weblogs and Social Media

</div>`

/^(\d{1,2}\.)+\d{1,2}(\s+)?[A-Z]/.test(str)

Purpose-built for displays of data

Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.

Learn more