Arrived in Linz yesterday night by train. Getting from tram station to the hotel was difficult since the wheel’s didn’t really work with all the snow on the group. I had completely overlooked the fact that there might be snow when packing in Toronto. This shot was taken during the lunch break at the Vamos workshop today. The pond must have been deep since it was definitely below zero yet the water wasn’t frozen over.

Thorsten and Maria brought me to the Monument of the Battle of Nations today. I went with the expectation of seeing a statue, only to find this monolithic structure overlooking a frozen-over lake. It looked as if it could have been out of the Lord of the Rings.

name = EAP-TTLS with PAP
author = Shawn MacLean
version = 1
require identity *Identity password *Password ca_cert *Path_to_CA_Cert
-----
network={
    ssid="$_ESSID"
    scan_ssid="$_SCAN"
    proto=WPA
    key_mgmt=WPA-EAP
    pairwise=TKIP
    group=TKIP
    eap=TTLS
    ca_cert="$_CA_CERT"
    identity="$_IDENTITY"
    password="$_PASSWORD"
    phase2="auth=PAP"
}

Add eap-ttls to /etc/wicd/encryption/templates/active, restart the GUI and the settings should now appear in the dropdown menu.

I’ve been getting into photography lately, and it’s been quite an interesting process so far. It’s incredible how a photograph can capture all the little details that you just didn’t notice when you were there in person. I’m only at the start of this journey (or addiction)… it’ll be interesting to see where I end up a year from now.

sudo apt-get install tomcat6

Next, we’ll need to raise the Tomcat heap size for confluence. Edit /etc/default/tomcat6 and add the line:

JAVA_OPTS="-Xms128m -Xmx1024m -XX:MaxPermSize=256m $JAVA_OPTS -Djava.awt.headless=true"

Now, we’ll need to grant security permissions to the Confluence webapp. To do this, create a file /etc/tomcat6/policy.d/05confluence.policy and place the following text in it:

grant codeBase "file:${catalina.home}/webapps/confluence/-" {
permission java.security.AllPermission;
};

grant {
permission java.lang.RuntimePermission "accessDeclaredMembers";
permission java.lang.reflect.ReflectPermission "suppressAccessChecks";
permission java.lang.RuntimePermission "defineCGLIBClassInJavaPackage";
};

Finally, we can restart Tomcat using the command:

/etc/init.d/tomcat6 restart

References

• Confluence installation guide
• Confluence security policy

def choose(def itemset, int choose) {
 
    def choose(def itemset, int choose) {
    def results = []
 
    //Initialize indices
    int[] indices = new int[choose]
    for (i in 0..<choose) {
        indices[i] = i
    }
 
    boolean hasMore = true;
    while (hasMore) {
        def combo = []
        for (i in 0..<indices.size()) {
            combo << itemset[indices[i]]
        }
        results << combo
        hasMore = { /* Closure to move the right-most index */
            int rightMostIndex = { /* Closure to find the right-most index */
                    for (i in choose-1..0){
                        int bounds = itemset.size() - choose + i
                        if (indices[i] < bounds) return i
                    }
                    return -1
            }() // execute closure
 
            // increment all indices
            if (rightMostIndex >= 0) {
                indices[rightMostIndex]++
                for (i in rightMostIndex+1..<choose) {
                    indices[i] = indices[i-1] + 1;
                }
                // there are still more combinations
                return true 
            }
            // reached the end, no more combinations
            return false
        }() // execute closure
    }
    return results
}

I’ve based my implementation off one from Applied Combinatorics by Alan Tucker. First, there is an indice array that stores the k positions in the itemset. The items at these index locations are the k-combinations. The algorithm increases the right-most index until it reaches the last element of the itemset, then increases, the second right-most index and so on.

I wouldn’t recommend this implementation when dealing with large itemsets. A deficiency with this one-method approach is that a single list is constructed containing all of the combinations. This list can grow to be very large, very fast. It can be easily adapted to provide one combination at a time by refactoring the hasMore check into a separate method. This way, it would act like an iterator. It’s too bad that Groovy doesn’t have support for the do-while loop as well, otherwise the hasMore closure could have been factored out into a really cool while check.

IJavaElement element = ...;
IEditorInput input = EditorUtility.getEditorInput(element);
IEditorPart editor = getSite().getPage().openEditor(input,
    (input instanceof FileEditorInput) ? : JavaUI.ID_CU_EDITOR 
            : JavaUI.ID_CF_EDITOR);
IDE.gotoMarker(editor, sNode.getMarker());

EditorUtility is an internal JDT class, but I couldn’t find a better way of doing this. A check on the return type of the getEditorInput call is necessary to since it can return either a file editor (for compilation units) or a class file editor.

There are a couple differences (most likely deficiencies) with my implementation. First, I use a list instead of a set when constructing the candidate word list. Second, I created a separate occurrence function in order to provide the smoothing capability for our occurrence distribution. Third, I didn’t really care much for a low line count. It’s not the LOC that matter in the end, it’s how easily you can comprehend the code!

public class SpellingCorrector {
  def wordoccur = [:]
 
  def words(File file) {
    Scanner scanner = new Scanner(file)
    def words = scanner.findAll{ x -> x.toLowerCase() ==~ ~/[a-z]+/  }
  }
 
  def train(List words) {
    words.each {
      wordoccur[it] = wordoccur.containsKey(it) ? wordoccur[it] + 1 : 1
    }
  }
 
  def edits1(String word) {
    def results = []
    int n = word.length()
    //Deletion. Remove a character.
    for (i in 0..<n)
      results << word[0..<i] + word[i+1..<n]
 
    //Transposition. Swap adjacent characters.
    for (i in 0..<n-1)
      results << word[0..<i] + word[i+1] + word[i] + word[i+2..<n]
 
    //Alteration. Change one character for another letter.
    for (i in 0..<n)
      for (c in 'a'..'z')
        results << word[0..<i] + c + word[i+1..<n]
 
    //Insertion. Add a letter in between the others.
    for (i in 0..<n)
      for (c in 'a'..'z')
        results << word[0..<i] + c + word[i+1..<n]
 
    return results
  }
 
  def knownedits2(String word) {
    def candidates = []
    edits1(word).each {
      candidates.addAll( edits1(it).findAll { wordoccur.containsKey(it) } )
    }
    return candidates
  }
 
  /**
   * Smoothing distribution. If the word hasn't been encountered (novel words),
   *  we give it an occurence value of 1.
   */
  def int occurrence(String word) {
    return wordoccur[word] == null ? 1 : wordoccur[word];  
  }
 
  def List known(List words) {
    return words.findAll { wordoccur.containsKey(it.toLowerCase()) }
  }
 
  def correct(String word) {
    def candidates = [word] + known([word]) + known(edits1(word)) + knownedits2(word)
    return candidates.max {  occurrence(it) }
  }
}

First, we don’t attempt to split words into two sub-words. For example, a common typo may be “Ihave” rather than “I have”. Second, the training and known function can definitely be improved to with support for proper nouns, stemming, and more. I think it would be a fun exercise to try and to create a simple implementation of these features, much like the SpellingCorrector.

So, Groovy has great support for regular expressions, list construction and compositions and best of all, closures! I also had a chance to play with the Groovy NodeBuilder (on a separate program), which is a great way for constructing tree structures. All said and done, I would hate to implement this in Java.

Update: The slides for my presentation have been uploaded. Download them here: [Download not found].

Software systems have grown larger and more complex in recent years. Generative software development strives to automate software development from a systems family by generating implementations using domain-specific languages. In current practice, specifying domain-specific languages is a manual task requiring expert analysis of multiple information sources. Furthermore, the concepts and relations represented in a language are grown through its usage. Keeping the language consistent with its usage is a time-consuming process requiring manual comparison between the language instances and its language specification. Feature model mining addresses these issues by synthesizing a representative model bottom-up from a sample set of instances called configurations.

This thesis presents a mining algorithm that reverse-engineers a probabilistic feature model from a set of individual configurations. A configuration consists of a list of features that are defined as system properties that a stakeholder is interested in. Probabilistic expressions are retrieved from the sample configurations through the use of conjunctive and disjunctive association rule mining. These expressions are used to construct a probabilistic feature model.

The mined feature model consists of a hierarchy of features, a set of additional hard constraints and soft constraints. The hierarchy describes the dependencies and alternative relations exhibited among the features. The additional hard constraints are a set of propositional formulas which must be satisfied in a legal configuration. Soft constraints describe likely defaults or common patterns.

Systems families are often realized using object-oriented frameworks that provide reusable designs for constructing a family of applications. The mining algorithm is evaluated on a set of applications to retrieve a metamodel of the Java Applet framework. The feature model is then applied to the development of framework-specific modeling languages (FSMLs). FSMLs are domain-specific languages that model the framework-provided concepts and their rules for development.

The work presented in this thesis provides the foundation for further research in feature model mining. The strengths and weaknesses of the algorithm are analyzed and the thesis concludes with a discussion of possible extensions.
Software systems have grown larger and more complex in recent years. Generative software development strives to automate software development from a systems family by generating implementations using domain-specific languages. In current practice, specifying domain-specific languages is a manual task requiring expert analysis of multiple information sources. Furthermore, the concepts and relations represented in a language are grown through its usage. Keeping the language consistent with its usage is a time-consuming process requiring manual comparison between the language instances and its language specification. Feature model mining addresses these issues by synthesizing a representative model bottom-up from a sample set of instances called configurations.

This thesis presents a mining algorithm that reverse-engineers a probabilistic feature model from a set of individual configurations. A configuration consists of a list of features that are defined as system properties that a stakeholder is interested in. Probabilistic expressions are retrieved from the sample configurations through the use of conjunctive and disjunctive association rule mining. These expressions are used to construct a probabilistic feature model.

The mined feature model consists of a hierarchy of features, a set of additional hard constraints and soft constraints. The hierarchy describes the dependencies and alternative relations exhibited among the features. The additional hard constraints are a set of propositional formulas which must be satisfied in a legal configuration. Soft constraints describe likely defaults or common patterns.

Systems families are often realized using object-oriented frameworks that provide reusable designs for constructing a family of applications. The mining algorithm is evaluated on a set of applications to retrieve a metamodel of the Java Applet framework. The feature model is then applied to the development of framework-specific modeling languages (FSMLs). FSMLs are domain-specific languages that model the framework-provided concepts and their rules for development.

The work presented in this thesis provides the foundation for further research in feature model mining. The strengths and weaknesses of the algorithm are analyzed and the thesis concludes with a discussion of possible extensions.

Download via UWSpace

Update: Here are the slides that I’ve used for my presentation.

Abstract

Software systems have grown larger and more complex in recent years. Generative software development strives to automate software development from a systems family by generating implementations using domain-specific languages. In current practice, such languages are built using a top-down approach. In addition, keeping the language specifications consistent with its usage is a difficult and manual task.

An algorithm for reverse-engineering a probabilistic feature model from a sample set of configurations is presented in this thesis. The expressions needed to construct a feature model are discovered by mining for so called association rules. The mined feature model consists of two components: a hierarchy of features that represent feature dependencies and alternative choices, in addition to a set of soft constraints that describe likely defaults or patterns exhibited in the sample set. Consequently, the mined model represents a language that describes the dependencies between features and its exhibited variability in a given sample set.

The mining algorithm is evaluated on a set of Java Applets to retrieve a model representing its framework usage. The retrieved feature model is further applied towards the development of framework-specific modeling languages (FSMLs), which are domain-specific languages that model framework-provided concepts and their rules for development.