Creating a script may be considered cheating if you're in it for money. If you're in it for fun, script away. That's what I always say.

Here's the gist of it:

#!/usr/bin/env perl
# words.pl: Find all possible slogan words from a single sentence.
use strict; $|++;

@ARGV == 2 or die "usage: $0 input_file output_file 'sentence'\n";
my ($infile, $outfile, $sentence) = @ARGV;
$sentence = $sentence || 'how much wood could a woodchuck chuck';

open INPUT, "< $infile" or die $!;
open OUTPUT, "> $outfile" or die $!;

my $stdout = select STDOUT;
$| = 1;
select $stdout;

my %sentence_letters;
my $stmp = $sentence;
$sentence_letters{$&}++ while($stmp =~ s/[a-z]//);

print "Using the sentence '$sentence'\n";
print "Found the following letters:\n";
print "\t$_ - ". $sentence_letters{$_} ."\n" foreach(sort(keys %sentence_letters));
print "Processing $infile for slogan words\n";

my $count = 0;
my @indicators = qw{\ / | .};
LINE: while(<INPUT>) {
    my $word = $_;
    my $tmp = $word;
    next LINE if($word =~ /['\&\d]/);
    my %word_letters;
    $word_letters{$&}++ while($tmp =~ s/[a-z]//);

    foreach(keys %word_letters) {
        next LINE if ($word_letters{$_} > $sentence_letters{$_});
    }
    print OUTPUT $word;

    my $word_len = length($word);
    open WORD_LEN_OUTPUT, ">> $outfile.$word_len";
    print WORD_LEN_OUTPUT $word;

    print $indicators[++$count % 4], "\r";
}

print "\nDone.\nView $outfile.* for words\n";

When I wrote this, I had only recently started using Perl. Please go easy on me if it's poorly written.

The script takes an input file, an output file format (e.g. words.txt will be words.txt.20 for words of 20 characters), and an optional sentence to parse.

It gets a set of letters in the sentence, then runs through the list of words to see if the word can be made from any combination of letters.

For instance, if your 'sentence' is "baby cakes", the script will create a hash of those letters and their counts. Conceptually, this looks like:

// hash is an array
hash['a'] = 2
hash['b'] = 2
hash['c'] = 1
hash['e'] = 1
hash['k'] = 1
hash['s'] = 1
hash['y'] = 1

If, while walking line-by-line through your list of words, the script sees 'abracadabra', the loop will return false because (conceptually):

word['a'] = 5
word['a'] <= hash['a'] == false

The script also employs some interesting stdout manipulation. This allows the script to output "spinner text" and update the current line when the terminating character is a line-feed.

To run the script in a linux-based environment, you may do:

mkdir ~/projects && cd ~/projects
git clone git://gist.github.com/1733871.git gist-1733871
cd gist-gist-1733871
perl words.pl /usr/share/dict/words generated.txt 'Good goly, Miss Molly'

You should see output similar to:

jim at schubert in ~/projects/gist-1733871 on master*
$ tree .
.
├── generated.txt
├── generated.txt.1
├── generated.txt.2
├── generated.txt.3
├── generated.txt.4
├── generated.txt.5
├── generated.txt.6
├── generated.txt.7
├── generated.txt.8
└── words.pl

0 directories, 10 files

If you look at generated.txt.7, you will probably see something similar to:

Hollis
Osgood
glossy
goodly
idylls
igloos
solids

Originally submitted at O'Reilly

Android Open Conference 2011: Complete Video Compilation

Android Open Conference 2011: Complete Video Compilation

Hours of Android enjoyment

Pros: Helpful examples, Easy to understand, Accurate, Concise

Best Uses: Intermediate, Student, Expert

Describe Yourself: Developer

There are a lot of videos here. If you're only planning to write apps for the market, you'll most likely not be interested in the Embedded Android talk or Scala as a Java replacement. If you don't work on iOS and never plan to, you can probably scan through Nick Farina's talk (sorry, Nick). I found many of the videos worthwhile, whether they related to actual app development or the business of apps.

I also really enjoyed the keynotes. Tim O'Reilly's talk is probably my favorite because I've been saying the same things about many of Tim's comparisons since I bought my first DROID a couple of years ago.

Even if you're familiar with Android development, you should definitely watch the videos by Ken Jones. He shows the start of a Twitter client. Although he didn't get very far in the actual coding, he will point you to the finished code. One aspect I loved about his talks is that he discusses a lot of best practices. Many tutorials you find online either don't discuss best practices or don't incorporate them.

Be sure to watch the Arduino videos. I hadn't heard about Arduino before this video and I was very impressed. In fact, I watched the keynote video twice.

Honestly, there are some videos here that I'm not that interested in. That doesn't detract from the overall usefulness of this video collection. If you're 25% of the way through a video and it hasn't hooked you yet, move onto the next because there is a plethora of information.

(legalese)

github:jimschubert/dotfiles

First, this script checks dependencies. My dependencies are git, ruby, vim, tree, rake, gem, bundle, and trash. You could check out the code and add any number of dependencies here. Rubygems and bundler are required because the script later installs all gems listed in Gemfile.

Next, the script copies ~/.bashrc to ~/.bashrc.local. This allows you to keep your current bash configuration as a 'local-only' config that doesn't get copied or committed to github.

The script, as I copied most of bootstrap.sh and the rakefile from @gf3, expects the repository to be cloned to ~/.dotfiles. From there, it calls rake.

Rake looks at every file in ~/.dotfiles and copies the corresponding file relatively from ~/ to, essentially, ~/dotfiles-backup/`date`. I recommend first running the backup to make sure your files are properly backed up.

rake backup

The script then calls 'bundle install' to install all gems. It then copies all files from ~/.dotfiles to replace those relative files that were previously backed up from ~/.

The post-install displays a message to remind you to edit .gitconfig and .hgrc.

Because I've done some copying and compiling, these are relative close to the three projects in the README for right now.

Here is an excerpt from the README:

Bash

$ tree ~/.bash
/home/jim/.bash
├── aliases
├── completions
├── completion_scripts
│   └── git_completion
├── config
├── functions
├── paths
└── prompt

The above files are loaded by .bashrc. The files are pretty self-explanatory, other than prompt which colorizes the bash prompt with tweaks for git.

Cool Aliases

• cd : pushd
• bd : popd
• cd.. | .. : back one directory
• cd... | ... : back two directories
• ^ up to five directories
• rm : trash
• undopush
• ip
• GET | HEAD | POST | PUT | DELETE | TRACE | OPTIONS

Config

• sets editor to vim
• sets English/UTF-8
• sets manpager
• sets commands to ignore in history
• sets noclobber (e.g. prevents cat > IMPORTANT_FILE mistakes )
• sets nocaseglob (e.g. ls ~/.B* will list contents of ~/.bash)

Functions

The two functions, md and c may not seem like much, but they simplify some commands. For example:

$ md projects; git clone git@github.com:jimschubert/dotfiles.git && cd dotfiles

In the above line, md will create the projects directory and cd into it.

c stands for 'code' and works like this:

jim at computer in ~
$ pwd
/home/jim
jim at computer in ~
$ c dotfiles
~/projects/dotfiles ~
jim at computer in ~/projects/dotfiles on master
$

You can change it to whatever shortcut and issue reload, which is also an alias from this setup.

Screenshot

Notice the color scheme and github branch notifications created by ~/.bash/prompt.

I'm a software developer. I love javascript. I love node.js. I love the direction Google is taking web development, user interaction, and the web in general. Installing node.js opens up a lot of possibilities for me on my CR-48. I don't know if this will work on anything other than the CR-48, considering the machine has to be in developer mode for these instructions.

If you don't have a chromebook yet, or you don't know what they are... where have you been? But seriously, visit http://www.google.com/chromebook/ and check them out.

Before I start, let me first say that following these instructions may void your warranty if you have one, open your machine up to vulnerabilities, or replace existing files and cause instability. If you don't know how to revert or fix any issues that may occur, don't continue. I offer no sort of warranty, support, or anything else. Consider this a 'hack' of sorts.

I found a blog post detailing how to install an archive package and ruby on rails in ChromeOS. I followed part of these instructions and I have modified them to fit my needs.

Prerequisites

• You must have a Chromebook, possibly only the CR-48
• You must be in 'developer mode'
• You must have a writable rootfs (see above link for developer mode)

Instructions

Downloading and installing xz

1. Download the xz package
2. Enter crosh or VT-2 (CTRL+ALT+T or CTRL+ALT+→)
3. If VT-2, login to the shell
4. Run on the terminal: cd /home/chronos/user/Downloads
5. Run on the terminal: tar -zxf xz-*.tar.gz
6. Run on the terminal: cd usr
7. Run on the terminal: cp * /usr/

Now that xz is installed in /usr/bin (verify by running on the command line: which xz), you will be able to extract certain files that are necessary for nodejs and possibly any other package you'd like.

Download and install nodejs and openssl.
The site claims openssl is optional, but node wouldn't open without it

1. Download nodejs
2. Download openssl
3. Enter the terminal again and navigate to /home/chronos/user/Downloads
4. Run on the terminal: xz -d node*.xz
5. Run on the terminal: tar -zxfv openssl*.tar.gz
6. Run on the terminal: cd usr
7. Run on the terminal: cp * /usr/

Now you should have a working install of nodejs. You can use npm, for instance, to install express and jade.

Is it possible to change the stub used to implement interfaces in Visual Studio 2008?

For instance, when I choose either
Implement interface 'IMyInterface'
or
Explicitly implement interface 'IMyInterface'

Instead of a number of properties that look like this:

    public string Comment
    {
        get
        {
            throw new NotImplementedException();
        }
        set
        {
            throw new NotImplementedException();
        }
    }
I'd like my properties to use the C# 3.0 auto-implemented properties and look like this:

    public string Comment {get;set;}
I want to do this to avoid forcing this interface to be an abstract class.

I've looked through the snippets in the Visual Studio folder, but I didn't see any that would be appropriate. I've also googled and searched SO, and found nothing.

If this isn't possible, does anyone have a macro I can steal?

Thanks.

I then discovered that you can edit the file at:

[program files]\Microsoft Visual Studio 10.0\VC#\Snippets\1033\Refactoring\PropertyStub.snippet

and modify the xml node 'Code' to contain the following:

<Code Language="csharp">
    <![CDATA[ $signature$ { $GetterAccessibility$ get; $SetterAccessibility$ set;} $end$]]>
</Code>

I really wish this was the default for .NET 3.0 and higher (since auto-implemented properties have been around).

Originally submitted at O'Reilly

Activate Your Web Pages

JavaScript: The Definitive Guide, 6th Edition

A tome of knowledge

Pros: Well-written, Accurate, Concise, Easy to understand

Cons: Huge

Best Uses: Student, Expert, Novice, Intermediate

Describe Yourself: Developer

This is an unbelievably thorough JavaScript book. It's definitely more of a reference book than a front-to-back read.

The first 12 chapters are an excellent introduction into the history of JavaScript and the core functionality of the language. There is a lot of information in these chapters that really shouldn't be overlooked-- especially Chapter 8: "Functions".

I especially appreciate the structure and the approach of the client-side section of the book. Flanagan makes it a point to avoid pushing JavaScript frameworks by explaining the features of the language first, followed by an explanation of the cross-browser simplification of using jQuery.

Later chapters cover additions to more recent browsers like client storage and HTML5 features. Those chapters unfortunately go by really fast. They're definitely not as in-depth as the JavaScript history part of the book.

The last two parts of the book are purely reference. This is pretty helpful, but it makes the book a lot thicker than most "guide" references.

I do agree with others that this book could use a few more examples, especially near the end when discussing JavaScript usage with new HTML5 APIs. If you're looking for an in-depth understanding of the core functionality of JavaScript, this is the book. It has helped me in numerous job interviews!

(legalese)

This code is also available as a gist. Fork it and contribute.

(function($) {
	$.fn.fixedHeader = function(options) {
		var settings = {
			selector: 'thead:first',
			cssClass: 'fixed',
			fixTo: 0
		};

		var _fixHeader = function(obj) {
			var header = $(obj.selector, obj.elem);
			if(header) {
				var parent =  header.parents('table:first') || header.parent();
				(parent && parent.css({ borderCollapse: 'collapse'}) );

				var data = header.data('fixedHeader') || header.data('fixedHeader', {
						top: header.offset().top,
						width: parent.find('tr:eq(1)').width(),
						cells: parent.find('tr:eq(1) > td'),
						processed: false
					});
				var top = data.top - $(document).scrollTop();
				if( top < 0 ) {
					header.addClass(obj.css);
					if(!data.processed){
						header.width(data.width);
						for(var i = 0; i<data.cells.length;i++) {
							$('th:eq('+i+')', header).width($(data.cells[i]).width());
						}
					}

				} else {
					header.removeClass(obj.css);
				}
			}
		};
		return this.each(function() {
			var self = this;
			if("object" === typeof options) {
				$.extend(settings, options);
			}
			if($(self).parents('table:first')){
				$(window).bind('scroll.fixedHeader', function() {
					_fixHeader({
						elem: self,
						selector: settings.selector,
						css: settings.cssClass,
						top: settings.fixTo
					});
				});
			}
		});
	};
})(jQuery);

A demo:

For my purposes, it allows me to maintain the project on two remote servers, one running Mercurial, the other running Git.

To see how it works, first install hg-git:

$ sudo easy_install hg-git

Then, edit your ~/.hgrc settings, adding to the [extensions] section:

[extensions]
hgext.bookmarks =
hggit =

Also, be sure your ~/.hgrc contains a valid email address:

[ui]
username = Jim Schubert <james.schubert@gmail.com>

Now, you can create a repository on github.com and push your Mercurial commits:

$ cd ~/projects/project_name
$ hg bookmark -r default master
$ hg push git+ssh://git@github.com/username/project_name.git
$ hg push

If you're only planning on using Mercurial to push changes to github or some other Git host, you can add that path to ~/.hgrc:

[paths]
default-push = git+ssh://git@github.com/username/project_name.git

// default package.js for an expressjs app using ejs and uglify-js
{
    "name": "application-name"
  , "version": "0.0.1"
  , "private": true
  , "dependencies": {
      "express": "2.4.6"
    , "ejs": ">=0.4.3"
    , "uglify-js": ">=1.1.0"
  }
}

Make sure the dependencies are installed with

npm install -d

Then, add the following make file and minify your JavaScripts as part of your make process!

JS = $(shell find public/javascripts/*.js)
MINIFY = $(JS:.js=.min.js)

all: clean $(MINIFY)

clean:
	rm -f ./public/javascripts/*.min.js

%.min.js: %.js
	node ./node_modules/uglify-js/bin/uglifyjs -o $@ $<

.PHONY: clean js minify

(expandable source is the same as the gist. It is doubled here to show in RSS feed readers.)

Instead of embedding the code directly, I'm using http://gist.github.com so changes to the file will show immediately in the post.

I have a fairly simple .vimrc:

syntax on " enabled syntax highlighting
:set number " line numbers
:set ai " autoindent
:set tabstop=4 " sets tabs to 4 characters
:set shiftwidth=4
:set expandtab
:set softtabstop=4 " makes the spaces feel like real tabs
" CSS (tabs = 2, lines = 79)
autocmd FileType css set omnifunc=csscomplete#CompleteCSS
autocmd FileType css set sw=2
autocmd FileType css set ts=2
autocmd FileType css set sts=2
" JavaScript (tabs = 4, lines = 79)
autocmd FileType javascript set omnifunc=javascriptcomplete#CompleteJS
autocmd FileType javascript set sw=4
autocmd FileType javascript set ts=4
autocmd FileType javascript set sts=4
" autocmd FileType javascript set tw=79

autocmd FileType jade set omnifunc=jadecomplete#CompleteJade
autocmd FileType jade set sw=2
autocmd FileType jade set ts=2
autocmd FileType jade set sts=2

" Highlight current line only in insert mode
autocmd InsertLeave * set nocursorline
autocmd InsertEnter * set cursorline

" Makefiles require TAB instead of whitespace
autocmd FileType make setlocal noexpandtab

" Highlight cursor
highlight CursorLine ctermbg=8 cterm=NONE

I also use the JavaScript syntax/indents found here:
https://github.com/pangloss/vim-javascript

You can access the completion by typing CTRL+X,CTRL+O.

If you have any other suggestions for using vim as a JavaScript editor, let me know!

Save this file as testy.snippet in your [Visual Studio]\VC#\Snippets\1033\Test directory.

Then, in the code editor, type testy, TAB+TAB to expand the snippet.

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
	<CodeSnippet Format="1.0.0">
		<Header>
			<Title>testy</Title>
			<Shortcut>testy</Shortcut>
			<Description>Code snippet for creating an NUnit unit test in C#</Description>
			<Author>James Schubert</Author>
			<SnippetTypes>
				<SnippetType>Expansion</SnippetType>
			</SnippetTypes>
		</Header>
		<Snippet>
			<Declarations>
				<Literal>
					<ID>summary</ID>
					<ToolTip>Summary</ToolTip>
					<Default>Summary</Default>
				</Literal>
				<Literal>
					<ID>name</ID>
					<ToolTip>Test name</ToolTip>
					<Default>TestName</Default>
				</Literal>
                <Literal>
                    <ID>description</ID>
                    <ToolTip>Test Case</ToolTip>
                    <Default>Assumption_Does_Expectation</Default>
                </Literal>
			</Declarations>
			<Code Language="csharp"><![CDATA[ ///<summary>
/// $summary$
///</summary>
[Test]
public void $name$_When_$description$()
{
	// Arrange

	// Act

	// Assert
}
$end$]]>
			</Code>
		</Snippet>
	</CodeSnippet>
</CodeSnippets>

In 1947, computers used relays instead of transistors as they are today (or vacuum tubes some time between). Relays are little (usually magnetic) switches which are essentially a mechanical representation of binary (on or off).

A relay

U.S. Naval Historical Center Online Library Photograph NH 96566-KN

When relays encountered foreign objects, they would no longer switch optimally, if at all. In 1947, a moth got caught on a relay and died. The team recorded the incident:

Relay #70 Panel F
(moth) in relay.

First actual case of bug being found.

They announced that they had "debugged" the system.

From that moment on, anything preventing a program from performing optimally or failing altogether has been referred to as a "bug". On the other hand, "debugging" has strayed somewhat to not only mean removing bugs from a program but is also used to mean a programmer is stepping through code to ensure it works as planned (whether or not bugs exist).

The history of computers is very interesting. Sometimes slang terms like "bug" are easily adopted by the community. Sometimes terms like "core" are used to refer to things which have evolved away from the original implementation.

For more information about Grace Hopper and "bugs", check out these resources:

• http://www.history.navy.mil/photos/pers-us/uspers-h/g-hoppr.htm
• http://en.wikipedia.org/wiki/Grace_Hopper
• http://en.wikipedia.org/wiki/Relay

Caveat!
Most times, these types are designed with private methods for a reason. There may be internal dependencies which can cause all kinds of problems if they're not met. Only do something like this if you're writing tests against the constructor or exploring the capabilities of Reflection.

The ConstructorInfo Class is the one we'll use. If your constructor is parameterless and non-public, you can instead do:

var myType = (MyType)Activator.CreateInstance(typeof(MyType), true /*nonPublic*/);

To instantiate an object from a non-public constructor with parameters, you'll need three things:

• the target type
• an array of parameter types (same order as signature)
• a reference to the constructor

Suppose your target type is defined as:

  class Example
    {
        public string Display { get; private set; }
        private Example(string msg)
        {
            Display = msg;
        }
    }

To instantiate this object, you can do the following:

      // 1. the target type
      var exampleType = typeof(Example);

      // 2. an array of parameter types (same order as signature)
      var argTypes = new Type[] { typeof(string) };

      // 3. a reference to the constructor
      // Because method signatures must be unique in parameters and return type,
      // this will return the matching constructor, or ctor will be null.
      ConstructorInfo ctor = exampleType.GetConstructor(
          BindingFlags.Instance | BindingFlags.NonPublic,
          null, argTypes, null);

      // similar to var example = new Example("You've set me privately!")
      var example = (Example)ctor.Invoke(new []{ "You've set me privately!" });

      Console.WriteLine("Example's display: {0}", example.Display);

Note:
ConstructorInfo requires FullTrust.

Of course, I answered it (correctly, might I add) as "it means capturing a variable inside a function". I was asked for an example, so I said, "Well, first I'd like to show a common mistake of closures when using loops." I gave the common looping mistake example:

var someArrayOfThings = /* [blah blah blah objects blah blah] */;
for (var i = 0, len = someArrayOfThings.length; i < len; i++) {
   var item = someArrayOfThings[i];
   // some function here to access item
}

There was some huffing about this. Maybe the developer didn't understand where I was going, or didn't care. Unfortunately, I wasn't asked to explain why it would cause an error. I should have given the example from MDN verbatim.

So, this guy gave me the following 'example':

var a = 1;
function a() {
  var a = 0;
  test = function() { alert(a); }
  test();
}
a();

Him: What does this do?
Me: Uh... nothing.
Him: No, you're wrong.
Me: Uh... I'm pretty sure I'm right.
Him: No, I'm sure you're wrong. This will alert 0. Always.

So sure? Try it yourself.

Why I was right.

• "Functional scoping" !== "closure"
• Hoisting redefines 'a' from function to number, not the other way around.
• Did he mean to define 'test' as a global?

This guy wasn't even talking about a 'closure', he was displaying functional scoping. I can understand the misconception between the two. A 'closure' occurs when a function closes the functional chain over some variable available at a greater scope, making that variable look like part of the function.

For instance:

var message = "outside";
var first = function() {
    var message = "inside";
    var second = function() { alert(message); }
    return second();
};

first(); // alerts "inside"

View on jsfiddle.net

In this example, the functional scope of the second function has access to the message which holds "inside". This is exactly the same concept as the developer was getting at. However, just calling the function, as in his example, doesn't close the outer function chain. Yes, variables captured inside functions will hold the value of the variable at the level of scope of when the function was declared. However, in his example he's just calling (or he thinks he is, I'll get to that later) one function to another:

call a ->
  set local a to zero ->
    define 'inner function' ->
      call inner function ->
        alert a from outer scope

As you can see, there is no 'capturing' of any variables. You could just as easily write this up without the added complexity of an inner function.

In my example, the execution goes more like this:

parse first ->
  create second function ->
    capture message "inside" ->
      compile second function to alert("inside") ->
        call newly compiled function

If you're familiar with C++, this is similar to a function pointer. In C#, it's almost like a compiled expression. Your function is actually encapsulating the data created by the closure.

Then again, I consider this all common sense about JavaScript.

On to the fundamental incorrectness of the not-mine example
So, I asked, "Both variables and the function are a?" "Yes" "Then, I'm sure it won't do anything!" (Ok, I just want to drive that home!) Then I said, "If you rename the function, then yes... it will alert 0."

See for yourself!

Function definition versus function declaration.
Here is an obviously very little known fact about JavaScript. You can declare a function in two general ways in JavaScript:

// function definition
var myFunction = function() { alert("My function!"); }

// function declaration
function myFunction() { alert("My function!"); }

I rarely ever use the second form of declaring a function.

In the function definition (first) example, only the variable is hoisted to the top of the current scope. 'myFunction' will always refer to your function. If you reassign myFunction to an integer, it's an integer. If you've previously defined it as an integer and reassign to a function, it's a function. This is the commonly expected behavior and is why you should declare all of your variables at the top of every function.

In the function declaration example, the entire function is hoisted!! This is done because JavaScript allows you to call methods which haven't physically been defined yet. So, the code the developer wrote for me and insisted was correct is actually parsed like this by JavaScript standards:

function a() {
  var a = 0;
  test = function() { alert("a");}
  test();
}
var a = 1;
a();

If you don't believe me, run the first example on jsfiddle and this example. If you look in your browser's console, you should see the same error for both bits of code. e.g. in Chrome 15:

Uncaught TypeError: number is not a function

As you can see, JavaScript implicitly raises all function declarations to the top of your scope! BE CAREFUL WITH THIS.

In contrast, had this developer written the function in my preferred way, I would have said, "It will alert 0, but you shouldn't be assigning the function to a global variable!" So, in the future, it's my way or the highway.

I highly recommend that every developer who writes JavaScript code read JavaScript: The Definitive Guide by David Flanagan. You will learn everything about the language you'll ever need to know. You'll learn quirks like the function-hoisting I've described here.

Even if you're like me, and you've been using JavaScript since 1998 or 1999, you'll learn a LOT. I'll admit, I used to hate JavaScript with a fiery passion. It wasn't until 2006 or so when jQuery appeared and made JavaScript cool again that I started to really dig into it. Anyway, read the book!