The following topics are covered:

• Basic Setup
• Email Verification
• Custom Views
• Overriding login/logout actions
• Custom encryptors
• Token authentication
• Permanent access token
• Single access token
• Using Http Basic Auth
• Simple Administrative Access
• Dual User Roles
• Let user login using either username or email

As a bonus, I created a simple rails application on github with devise all set up. All of the covered topics have been implemented in a separate branches so you merge in the features you want or diff between the branches to see all the things that need to be modified to activate that feature.

The presentation itself was recorded, and is available on Vimeo.

We ended up using the Apache commons-net-ftp library that can be found here: http://www.docjar.com/jar_detail/commons-net-ftp-2.0.jar.html

After adding that jar to the build path, the implementation was pretty straightforward:

import org.apache.commons.net.ftp.FTPClient;
 
FTPClient ftpClient = new FTPClient();
 
try {
    ftpClient.connect(InetAddress.getByName(SERVER));
    ftpClient.login(USERNAME, PASSWORD);
    ftpClient.changeWorkingDirectory(PATH);
 
    if (ftpClient.getReplyString().contains("250")) {
        ftpClient.setFileType(org.apache.commons.net.ftp.FTP.BINARY_FILE_TYPE);
        BufferedInputStream buffIn = null;
        buffIn = new BufferedInputStream(new FileInputStream(FULL_PATH_TO_LOCAL_FILE));
        ftpClient.enterLocalPassiveMode();
        ProgressInputStream progressInput = new ProgressInputStream(buffIn, progressHandler);
 
        boolean result = ftpClient.storeFile(localAsset.getFileName(), progressInput);
        buffIn.close();
        ftpClient.logout();
        ftpClient.disconnect();
    }
 
} catch (SocketException e) {
    Log.e(SorensonApplication.TAG, e.getStackTrace().toString());
} catch (UnknownHostException e) {
    Log.e(SorensonApplication.TAG, e.getStackTrace().toString());
} catch (IOException e) {
    Log.e(SorensonApplication.TAG, e.getStackTrace().toString());
}

The ProgressInputStream is a custom version of InputStream that takes an instance of android.os.Handler in constructer. the overridden read method sends an update to the Handler after every 10KB transfered (Thanks to Steven Schlansker on Stackoverflow). The following excerpt contains the general idea of how to pass information back to the UI thread.

package com.royvandewater.utils;
 
import java.io.IOException;
import java.io.InputStream;
 
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
 
public class ProgressInputStream extends InputStream {
 
    /* Key to retrieve progress value from message bundle passed to handler */
    public static final String PROGRESS_UPDATE = "progress_update";
 
    private static final int TEN_KILOBYTES = 1024 * 10;
 
    private InputStream inputStream;
    private Handler handler;
 
    private long progress;
    private long lastUpdate;
 
    private boolean closed;
 
    public ProgressInputStream(InputStream inputStream, Handler handler) {
        this.inputStream = inputStream;
        this.handler = handler;
 
        this.progress = 0;
        this.lastUpdate = 0;
 
        this.closed = false;
    }
 
    @Override
        public int read() throws IOException {
            int count = inputStream.read();
            return incrementCounterAndUpdateDisplay(count);
        }
 
    @Override
        public int read(byte[] b, int off, int len) throws IOException {
            int count = inputStream.read(b, off, len);
            return incrementCounterAndUpdateDisplay(count);
        }
 
    @Override
        public void close() throws IOException {
            super.close();
            if (closed)
                throw new IOException("already closed");
            closed = true;
        }
 
    private int incrementCounterAndUpdateDisplay(int count) {
        if (count > 0)
            progress += count;
        lastUpdate = maybeUpdateDisplay(progress, lastUpdate);
        return count;
    }
 
    private long maybeUpdateDisplay(long progress, long lastUpdate) {
        if (progress - lastUpdate > TEN_KILOBYTES) {
            lastUpdate = progress;
            sendLong(PROGRESS_UPDATE, progress);
        }
        return lastUpdate;
    }
 
    public void sendLong(String key, long value) {
        Bundle data = new Bundle();
        data.putLong(key, value);
 
        Message message = Message.obtain();
        message.setData(data);
        handler.sendMessage(message);
    }
}

Since the existing plugin was not capable of meeting that requirement, Josh Wolfe from ResultOf(programming) = Moods.happy and I collaborated to create a custom plugin that provides exactly this functionality. The latest development code for the plugin can be found on GitHub at django_testing and a packaged build can be found here: com.royvandewater.django_testing_1.0.1.jar

To install, simply drop it into your eclipse plugins directory (it was ~/.eclipse/org.eclipse.platform_3.5.0_x/plugins/). To use, place the cursor anywhere within a file containing Django tests and press Alt+Shift+F11. If your cursor is currently inside of a specific test method, it will run only that method. If it is outside any test methods but still within the class, the plugin will execute all test methods in that class. Lastly, if you are in a function where the name is not prefixed with “test”, the plugin will execute the last run test. This is great for writing a test and running it from another file as you write the implementation.

        1795.0
        /path/to/image1.jpg
 
        5
        /path/to/image1.jpg
        /path/to/image2.jpg
 
        1795.0
        /path/to/image2.jpg
 
        5
        /path/to/image2.jpg
        /path/to/image1.jpg

Where all paths are absolute. The xml file can be chosen as a wallpaper in the standard gnome wallpaper picker by going pressing add and choosing “All files” from the file filter drop down.

To make the process of creating these xml files a bit simpler, I made a python script that takes all images in a directory and generates an xml file for them. To use it, simply run it in the directory where the images are located and it will generate a file called “desktop.xml”. The default transition time is 1795 seconds (30 minutes). To change the switch time, supply the new interval in seconds as an argument:

./ubuWallGen 1200

You can get the latest version of the script using git:

git clone git://github.com/royvandewater/ubuWallGen.git

You can also download the script directly here

Students often shout “Wikipedia is bad” and “Wikipedia is inaccurate”. They are going to high school in a generation where Wikipedia has already existed and high school teachers have already taken a position on it. It seems they have taken the stand that Wikipedia is bad and they tout its inaccuracy as the reason why. I believe that telling students this is a disservice while understanding their position. Teachers realize that as students trust and become reliant on Wikipedia, they will lose the education required at this stage in their life to go out and perform their own research. This is certainly a justified concern and should be addressed. I just don’t think that claiming it is inaccurate is the correct way to go about it.

Although the potential for inaccuracy exists due to Wikipedia’s user-generated content, case studies show that in general, Wikipedia is more accurate than more widely respected published sources. Because of their unpublished nature, Wiki articles can be corrected immediately when errors are discovered. On the other hand, an encyclopedia serving the same information would have to wait until the release of a new edition, or at least the release of an errata, before correcting their mistake. This lends Wikipedia much more flexibility in the face of inevitable human error.

Instead of its falsely perceived inaccuracy, what teachers should be demonstrating to students is Wikipedia’s incompleteness. The purpose of Wikipedia, or any other encyclopedia for that matter, is to provide a broad overview of a topic and not a detailed accounting of all aspects relating to the subject. One should use Wikipedia to become versed in a subject they had previously not heard of. After gaining a general picture of the concept, the researcher could then go into depth by reading specific journal articles and books on the topic. By having this relatively vague mental picture of the subject matter, the researcher is in a much better position to understand the in-depth material.

Wikipedia should not be seen as the enemy of research and neither should it be perceived as the compendium of all information. It should be used as a tool to gain a general understanding in a particular subject to prime the learner for in-depth research. Technical inaccuracies in Wiki articles are not of a major concern when Wikipedia is used in this way; the researcher will generally discover the inaccuracy when they dive into the specialized books and journal articles and can then quickly correct the mistake for the benefit of the next passer-by (citing their recently read article as the source). In the mean time, little harm was done because the researcher was not attempting to gain knowledge about specific details on the topic at the time the error was read.

In conclusion, I believe that if students were taught to use Wikipedia as a research tool, in the same way deprecated encyclopedias were used in previous generations, it will greatly enhance their learning and researching capabilities.

"activate vimsh
map ,sh :source /path/to/vimsh/vimsh.vim

This is the most basic call, causing the current buffer to split horizontally and open a shell in the top window. I use a slight variation of this shortcut to make sure that the shell is always opened at the bottom of the screen. Just append Ja to the last shortcut:

map...vimsh.vimJa

If you would like vim to open a python prompt, just add python:

map...vimsh.vimJapython

To have it execute the python file you are currently editing and then remain in interactive shell mode afterwards, use the following (note that the post-execution interactive shell is only supported on python3):

map...vimsh.vimJapython3 -i #

If you would like to have the shell execute the python script, but not go into the interactive python shell afterwards, omit the “-i” from the above command. This is great for running unit test programs.

The major drawback to vimsh is that the commands listed above work only once. If you terminate the shell session and close the window so you are left with your original document (A state that seems to be identical to the state before we opened the shell) and try to execute the command again, it creates the shell terminal inside of the currently active window instead of splitting it like it did the first time. This issue might be resolved by changing some configuration options, but the application is not well documented. The documentation basically says “Look in the source file if you want to find out what the configuration options are”, something I’ll have to get around to eventually. Another issue with vimsh is that the shell has some display issues with more complex programs. This prevents the shell window from opening lynx, irssi and most other ncurses applications.

As for vim-shell, I haven’t tried it yet as it requires a recompilation of vim. I’ll make another post once I’ve found the time to get it working.