8:00 – 2:30 SR

• I’m thinking about how the edges in a network can have certain characteristics
  • Bandwidth – the capacity of the edge. Can be expressed as used and potential
  • Frequency – how often the edge is used. Bandwidth provides a ceiling on this
  • Richness – I’m not sure how to think about this. In the most basic case, this could be an expression of information content (i.e. an infrequent transmission with lots of content is equivalent to a frequent transmission with low content). But when we layer on context and meaning, all kinds of additional information gets ‘compressed’ into the message – a glance can be nothing or everything. Ideally, the description of the edge should contain some way of accessing that context, and shouldn’t be considered simply a link
• Along this lines, I found this paper: Lexical chains as representations of context for the detection and correction of malapropisms. Lexical chains are certainly one way of representing context.
• Another way of thinking about richness is in terms of similarity. If the link is carrying the same payload over and over again, then there isn’t much richness. So can we look at similarity as a way of determining how rich a link is? An Information-Theoretic Definition of Similarity. And here’s looking at news headlines, which might be relevant to short posts or tweets: Similarity for news recommender systems
• And this reminded me of Princeton’s WordNet, which could be really helpful.
• Ok, back to the database
  • Based on the above thoughts, I’m adding assoc_type to tn_associations
  • Here’s a query that pulls all the parts together. According to everything I’ve read, joins are probably the most efficient way to do this (size and speed):

    select u.login as `Link Created By`, a.created_on as `Created On`, at.name as `Assoc Type`, si.text as Source, st.name as `Source Type`, ti.text as Target, tt.name as `Target Type`
    from  tn_associations a
    inner join tn_users u on a.user_id=u.uid
    inner join tn_types at on a.assoc_type = at.uid
    inner join tn_items si on a.source_id = si.uid
    inner join tn_types st on si.item_type = st.uid
    inner join tn_items ti on a.target_id = ti.uid
    inner join tn_types tt on ti.item_type = tt.uid;

  • Now I need to load and save a named network from a particular user or any variants up to and including all networks from all users, without redundant nodes/edges…

8:00 – 5:00 SR

• Filled out contact info for Steve
• The stricter trust chain did not work. I had Ronda go back to the looser one.
• Fixed attraction/repulsion/linkScalar it’s 1.0, 10.0, 10.0 for defaults
• Ran into a weirdness with <input type=”range> and browsers. Chrome is fine. FF and Chrome have differing default widths and margin/padding. Had to add the following to get all ranges to work similarly:

  .forceRange{
      position: absolute;
      width: 120px;
      right: 10px;
      margin: 0px;
      padding: 5px;
      z-index: 2;
  }

• Back to figuring out the AlchemyNews API. Blew up the limit again, being careful. I think that the news API, aside from behaving poorly (things like ‘&q.enriched.url.concepts.concept.relevance=0.9’ don’t work). Think I’m going to add more user interaction and less machine learning. Store it all for later page ranking?

8:00 – 2:30 SR

• Updated the truancy report.
• Adding multi-connections to network construction
• Woohoo!
• Then
  • NewsAPI or database.

8:00 – 2:00 SR

• The production server is behaving again!
• Wrote up some thoughts on TypeScript interfaces and fat arrow notation.
• Working out more subtle network linkages. An item is current (selected?) has potentially several other items that will connect to it. Selecting should also bring up the search results associated with that item (create an itemlist of nearest neighbors). Maybe the item should be created before the results of the query come back. That might make things more modal.

8:00 – 4:30 SR

• The production server isn’t visible through the browser, though the test server is. It first I thought it was pre-populated keychains, but when the servers are set up identically, the production server still doesn’t cooperate. Ronda’s putting in a ticket.
• Helped Ronda generate a PKI request for the new dev server, she’s going to try to make it work on the other two.
• Looking at Dong’s code, I cannot figure out why he needs fat arrow. His:

  public promiseCaller():void{
     this.promise = this.service.getQueries();
     this.promise.then(this.processData, this.errorData);
  }
  
  public processData = (data:any):void => {
     console.log("got data");
  };
  
  public errorData = (data:any):void => {
     alert("error getting data");
  };

• And mine

  private goodUserQuery (response:any) {console.log("got data");}
  private goodUserQuery (response:any) {alert("error getting data");}
  public promiseCaller():void{
      this.queryService.submit(qstr, this.goodUserQuery, this.errorResponse);
  }

• Which calls (in the service):

  public submit(query:string, goodResponse:any, errorResponse:any):any {
     return this.httpService(query).then(goodResponse, errorResponse);
  }

• And it looks like Google won’t let me use their images as textures. Working at downloading on the server side and storing in a local directory, using PHP. That works just fine! And to keep from downloading the same pix all the time, added a check as well. PHP has pretty much everything you’d ever want to do stuff on the web. But no typing. Must check out Hack one of these days.
• Adding connections. Finally! Simple conditions are working and up.

8:00 – 4:00SR

• Prime day. May poke at that a bit. Disappointing.
• Call Porsche for oil change and chin cover repair – nope. Tomorrow?
• Get network connections working – Almost!
• Add news API integration – nope