I’ve been working one a few new features in my side project huboard
and they are pretty awesome.

Since the start I’ve always prioritized features by what adds the most value to github issues. That means features github already provides are much lower in priority, which is why you still can’t add issues from huboard. Eventually I will add it, but github already provides that functionality or you could use other tools gem install ghi. Even more importantly huboard is open source, I would love it if someone would fork it and add those features.

So what’s new in huboard that github doesn’t provide?

Milestone ordering

Huboard provides the ability to prioritize your milestones using a more macro oriented manager pants view.

From here you can happily drag your milestones into the desired order

Issue ordering

Huboard provides the same ordering ability for issues.

Notice how issue #23 is between #31 and #35

Aggregate issues from multiple repositories

Huboard can now aggregate issues from multiple repositories into one singular overview of all your repositories

Simple as adding a label to your repo name Link <=> rauhryan/ghee

Huboard shows issues from both repositories!

Github issues just got a little more awesome!

-Ryan

So a couple weeks ago I finally decided to learn how to use bash functions. I knew they existed but I decided to ignore them for the longest time.

Often times you find yourself typing the same things over and over again into the shell. In our app we deploy 3 windows services and managing them can get really tedious.

~/lecode>sc query DovetailEmail-default
~/lecode>sc stop DovetailEmail-default
~/lecode>sc delete DovetailEmail-default

~/lecode>sc query DovetailRulesEngine-default
~/lecode>sc stop DovetailRulesEngine-default
~/lecode>sc delete DovetailRulesEngine-default

~/lecode>sc query DovetailMessaging-default
~/lecode>sc stop DovetailMessaging-default
~/lecode>sc delete DovetailMessaging-default

That’s a lot of typing, granted its not that bad when you use your bash history. But you end up hitting the up arrow and changing one word a lot.

Functions!

So when you keep repeating yourself over and over again you can quickly write a function that can save you precious keystrokes

~/lecode>function fsc() {
for name in Email RulesEngine Messaging
do
sc $1 Dovetail$name-$2
done
}


Now I can happily type
~/lecode>fsc query default
~/lecode>fsc stop default
~/lecode>fsc start default

It works for other repetitive tasks as well, ie the steps to deploy our app is as follows

~/lecode>rm -rf mydefault
~/lecode>bottles create-all
~/lecode>bottles bundle mydefault -profile default
~/lecode>mydefault/BottleRunner.exe deploy -profile default

Again… pretty easy to just use my bash history and hit the up arrow to run all the commands
but its really easy to make a function

~/lecode>function fdeploy() {
rm -rf my$1
bottles create-all
bottles bundle my$1 -profile $1
my$1/BottleRunner.exe deploy -profile $1
}


Then bam!

~/lecode>fdeploy default
~/lecode>fdeploy storyteller
~/lecode>fdeploy hrdemo

See thats way mo ‘betta than creating a .bat file cause then you have run in cmd.exe, you have to ignore it in git repository, clean up after yourself later….

And I just don’t like that, not one bit.

-Ryan

My primary work machine is Ubuntu *happy face* but my day to day work is in a windows VM *sad face*

Our project uses a lot of nugets packages and some of those nugets bring in command line tools that we use while developing our project. For example we use a tool called bottles that can package our application up into “deployable zipfiles”.

Anyways that tools comes into our project via nuget, but I have to call that tool from the command line all the time. So my coworkers made a batch file that will find the exe in the nuget packages folder and delegate all the command line argument to it so we can all bottles from the root of our project like this

~/lecode/leproject>bottles create-all

Here’s the source code for that cmd file.

@ECHO OFF
SETLOCAL
REM Find BottleRunner in one of the installed Bottles nuget packages
FOR /R %~dp0\source\packages %%G IN (BottleRunner.exe) DO (
	IF EXIST %%G (
      SET RUNNER=%%G
	)
)
IF EXIST %RUNNER% (
    GOTO FOUND
)
IF '%RUNNER%'=='' GOTO NOTFOUND

:FOUND
%RUNNER% %*
GOTO :EOF

:NOTFOUND
ECHO BottleRunner.exe not found.
EXIT /B 1

Pretty simple, it runs a for loop looking for any files named BottleRunner.exe and sets a variable. Then it checks if that variable was found and does a GOTO *gasp* delegating arguments to the exe.

That’s all well and good but I want to run bottles from bash, cause I’m in bash way more that cmd and lets face it I hate cmd.exe and don’t want to use it.

So I came up with this piece of awesome.

#!/bin/bash
for exe in `find source/packages -type d | sort -r | grep "Bottles\.Tools" | sed -n 1p | xargs grep -rl "BottleRunner\.exe" | sed -n 1p`; 
do 
    $exe $@; 
done

find source/packages -type d | sort -r | grep "Bottles\.Tools" | sed -n 1p | xargs grep -rl "BottleRunner\.exe" | sed -n 1p

Holy crap! that’s a nasty one, what does it do?

find source/packages -type d
Find all directories (-type d) in the source/packages folder

find source/packages -type d | sort -r
Pipe that into sort in order to sort it descending (-r)

find source/packages -type d | sort -r | grep "Bottles\.Tools"
grep for folders that contain Bottles.Tools

find source/packages -type d | sort -r | grep "Bottles\.Tools" | sed -n 1p
Only print the first line (-n 1p) so that the highest version number gets printed

find source/packages -type d | sort -r | grep "Bottles\.Tools" | sed -n 1p | xargs grep -rl "BottleRunner\.exe"
Recursively search that directory (-r) for for files named BottleRunner.exe and print out the file path (-l)

find source/packages -type d | sort -r | grep "Bottles\.Tools" | sed -n 1p | xargs grep -rl "BottleRunner\.exe" | sed -n 1p
Print the top line in case there is a config file BottleRunner.exe.config

for exe in `find source/packages -type d | sort -r | grep "Bottles\.Tools" | sed -n 1p | xargs grep -rl "BottleRunner\.exe" | sed -n 1p`; do $exe $@; done
Throw that into a for loop so that I can delegate all of the arguments ($@) to the latest bottlerunner.exe

You can use that to delegate to other tools as well just change “Bottles.Tools” with the name of you nuget and BottleRunner.exe to the name of the exe you want.

Now I can safely run bottles from bash

bottles create-all

So much WIN!

Don’t herp derp it, use my sweet script and avoid cmd.exe

-Ryan

I can’t stress enough how important it is to learn what every shell program you prefer. cmd, bash, zsh, powershell, doesn’t matter pick one and learn it! There is endless productivity and general sanity to be gained by being able to rip out mini rube goldberg machines on a daily basis.

Lets walk through a “practical” example of using several commands to make a tedious job easier. Lets convert a bunch of css files into scss files only using the shell.

For the sake of interactivity create a test directory and dump a few css files into it.

~/lecode> mkdir f_in_awesome
~/lecode> cd f_in_awesome
~/lecode/f_in_awesome> for f in herp derp nerp blerp; do touch $f.css; done
Just a simple loop to create some tests files.

Now that we have some files lets practice building out a command to move them.

~/lecode/f_in_awesome> find . -maxdepth 1 -name "*.css"
Find all the css files in the current directory but don’t go into any subdirectories

Now turn that into a loop
~/lecode/f_in_awesome>for f in `find . -maxdepth 1 -name "*.css" `; do echo $f; done

Cool our loops correct now lets practice moving them, notice I said practice! I like to use echo to fine tune my Rube Goldberg machines before I set it off that way I get it right in one take.

First lets figure out how to get just the filename from the path.

~/lecode/f_in_awesome>for f in `find . -name "*.css" -maxdepth 1`; do echo $(basename $f); done
Cool $(basename …) is a function in bash that will return just the filename

~/lecode/f_in_awesome>for f in `find . -name "*.css" -maxdepth 1`; do echo mv $(basename $f) scss/_${$(basename $f)%.*}.scss; done
Now lets use substitution ${ %.*} to strip off the file extension so that we can change it to scss

Nice! Now remove echo and move them for realsies!

~/lecode/f_in_awesome>for f in `find . -name "*.css" -maxdepth 1`; do mv $(basename $f) scss/_${$(basename $f)%.*}.scss; done

OOOPS! Forgot to make the directory

~/lecode/f_in_awesome>mkdir scss && !!

OK! Couple new concepts there… This is the command line, you are gonna make mistakes! Thats why we have things like `git reset –hard`. Bash makes things nice, you can chain commands together with && and !! is a shortcut to (last command). So mkdir scss && !! will create our directory and run the last command.

We aren’t quite done. We created some sass partials, now we need to make an “application” file that imports all our partials.

~/lecode/f_in_awesome>cd scss

Now lets practice again, I want to print out just the file name without the underscore and stream that into a file
~/lecode/f_in_awesome/scss>for f in `find . -name "_*.scss"`; do echo ${$(basename $f)##*_}; done
Now lets use substitution ${ ##*_} to take everything after the _

~/lecode/f_in_awesome/scss>for f in `find . -name "_*.scss"`; do echo ${${$(basename $f)##*_}%.*}; done

And then the same substitution we used before to strip off the extension.

~/lecode/f_in_awesome/scss>for f in `find . -name "_*.scss"`; do echo @import \"${${$(basename $f)##*_}%.*}\"\;; done

Now add the @import syntax to make sass happy

~/lecode/f_in_awesome/scss>for f in `find . -name "_*.scss"`; do echo @import \"${${$(basename $f)##*_}%.*}\"\; >> application.scss; done

Ooops! Forgot to touch the file!
~/lecode/f_in_awesome/scss>touch application.scss && !!

There you have it! I was able to take our app from upwards of 40-60 really granular css files into nice sass partials in no time. Sass will even compress them which was a HUGE win on the performance of our latest release!

Can you imagine moving all those files with the file explorer, renaming all of them, then creating the import file by hand??? Hellz to the no! That’s why learning your shell will be the best things will will ever do!

Don’t Herp, Learn teh shell!

-Ryan

Piping grep into grep

I was spelunking my .bash_history and came across this little piece of awesome.

~/lecode> find source/ -type f | grep -v " " | xargs grep this\.Asset.* | grep dovetail | grep -v .*\.css | grep -v dovetail\/dovetail | cut -d \: -f 1 | xargs gvim

Wow! So what the heck was I doing there? Lets walk through it.

So I’ve got a problem… I am OCD about where asset files are located in our project. It’s a complete mess and every time I complain about it…

“It will be too hard to go through the app and change all the paths…”

“You under estimate my command line awesome-itude!”

Turns out its not that hard of a problem, let me break it down. All of our asset imports are abstracted out into an extension method we call from our view

<% this.Asset("myasset"); %>

Perfect so I have something consistent to grep for

~/lecode> find source/ -type f
Find all the files in the source directory

~/lecode> find source/ -type f | grep -v " "
Pipe that into grep and inverse match any path with a space (-v)

~/lecode> find source/ -type f | grep -v " " | xargs grep this\.Asset.*
xargs that path into grep and search each file for any lines containing `this.Asset*`

~/lecode> find source/ -type f | grep -v " " | xargs grep this\.Asset.* | grep dovetail
I only care about asset calls that contain dovetail

~/lecode> find source/ -type f | grep -v " " | xargs grep this\.Asset.* | grep dovetail | grep -v .*\.css
Inverse grep (-v) any lines containing .css

~/lecode> find source/ -type f | grep -v " " | xargs grep this\.Asset.* | grep dovetail | grep -v .*\.css | grep -v dovetail\/dovetail

Inverse grep (-v) assets that start with dovetail/dovetail because those are correct.

~/lecode> find source/ -type f | grep -v " " | xargs grep this\.Asset.* | grep dovetail | grep -v .*\.css | grep -v dovetail\/dovetail | cut -d \: -f 1

Notice how grep outputs the file path and then the match. We can use cut to parse the output on the “:” (-d \:) and take the first column (-f 1)

~/lecode> find source/ -type f | grep -v " " | xargs grep this\.Asset.* | grep dovetail | grep -v .*\.css | grep -v dovetail\/dovetail | cut -d \: -f 1 | xargs gvim
Now I have my file names, xargs that into gvim and it loads up a new instance of gvim with all the files I need to change in a buffer list. Now I can make my change and :bnext (buffer next) to the next file.

“It looks like you are trying to change a bunch of files… Want to use find and replace?”

“Shut up troll!”

Deeerp
-Ryan

Last time I posted a quick intro into basic shell programming.

“Bash isn’t programming, its scripting…”

“Shut up troll, its programming”

This time I’d like to quickly explain loops.

I’ll give you a quick example of how you can use a loop to do some simple things.

Lately I’ve been working on FubuMVC and the project has a *few* repositories and it can be a pain in the ass to update all of the git repositories. Luckily bash is here to help.

I happened to have all Fubu related project in one directory so bash makes this pretty simple.

~> cd ~/lecode/fubuproj

~/lecode/fubuproj> ls

.
fubumvc
FubuFastPack
ripple
bottles
fubucore


Ok now lets test out a simple for loop.

~/lecode/fubuproj> for d in `ls`; do echo $d; done

.
fubumvc
FubuFastPack
ripple
bottles
fubucore


Ok awesome, now we are getting some where.

“But what if I have files as well as directories…”

~/lecode/fubuproj> for d in `ls -d */`; do echo $d; done

When you are working in bash, there are a lot of gotchas that can catch you off guard. One of those gotchas is aliases… I have ls aliased to `ls –color -xXw80` to make it look the way I want it to by default. The gotcha is –color that will bit you when you try and pipe color into other things. So to avoid aliases you can point to ls directly from /bin/ls

~/lecode/fubuproj> for d in `/bin/ls -d */`; do echo $d; done

Now you can cd into the directory and run `git status` to make sure you don’t have any outstanding changes.

~/lecode/fubuproj> for d in `/bin/ls -d */`; do cd $d; git status; cd ..; done

If everything is checked, I’ll make sure they are all on the master branch

~/lecode/fubuproj> for d in `/bin/ls -d */`; do cd $d; git checkout master; cd ..; done

Fetch the latest changes…

~/lecode/fubuproj> for d in `/bin/ls -d */`; do cd $d; git fetch; cd ..; done

And catch up my master branch

~/lecode/fubuproj> for d in `/bin/ls -d */`; do cd $d; git rebase origin/master; cd ..; done

Nice… Now all my projects are up to date.

HerpDerp

-Ryan

Since I’ve started at Dovetail in June the best tool I’ve sharpened is my command line skills. My first week at Dovetail we got a surprise visit from @bob_pace and while pairing with him I was amazed by how effective he was with the command line. Well that really motivated me to improve my own skills.

I’m gonna run through some basic building blocks that are required to work with files in the command line.

~> find

First step is finding the files you want to work with.

* List all the files in your pwd (present working directory). This will list every file and directory and recursively from the
path you have specified

~> find .

* List all files with certain extension

~> find . -name "*.js"

* List only files and not directories

~> find . -type f

* Protip: If you suspect files will spaces in the name (try to never do this!)

~> find . -type f -print0

~> xargs

xargs is your favorite buddy/friend/pal when working will large lists of files. The only thing xargs does, is take whats piped into it and stick it on the end of the next command.

Try it yourself

~> find . -name "*.js" | echo

Whoops… WTF, there is no output. Now try

~> find . -name "*.js" | xargs echo

See if put it at the end of the next piped command, simple right!?

~> grep

ZOMG! grep has changed my life…

grep will search a line of input for with a regular expression that you provide it. If you pass it a file name it will search each line of the file and output any matches.

~> echo "hello" | grep hello

See simple right!

The command line is all about chaining inputs and outputs, its magical! Lets do that.

For example if you are using nuget and you want to know what version of FubuMVC you are using

~> find. -name "packages.config" | xargs grep -h FubuMVC\.References

~> sed

Now lets talk about whats *really* awesome about the command line. MUTHA !@#$in sed! stands for stream editor and its amazing.

Back in the early days of using nuget, we got into a situation where it was adding multiple version of the same dependency in our package configs…. its was a pain in the ass! Mostly due to the fact we have 30 projects and a lot of them are bottles that are not loaded with the core products solution file. Well if you are using the Visual Studio nuget manager fail sauce POS it would get all messed up and start putting extra references in the package configs. When we switched to our own tool to manage this madness, ripple it got all sorts of messed up.

So sed to the rescue! So the great thing about the command line is that you can fine tune your command before you actually go through with it

~> find. -name "packages.config" | xargs grep -h FubuMVC\.References | sed d

Bam that should return no output, you are telling sed to delete any line that is passed to it. Now lets say that all of your project have two references to Fubu 0.9.2.722 and 0.9.3.731 and you want to delete the lower one. Lets practice first.

~> find. -name "packages.config" | xargs grep -h FubuMVC\.References | sed /FubuMVC\.Reference\..*722/d

That should only output the higher version of the two versions. Now that we know it works… we can put it all together and get destructive. We will just tweek our current command a little. Switch the grep flag to -l (lower case L), this will tell grep to output the filename only. Then we’ll need to pipe this to sed, but we’ll need to xargs it to the end since we want sed to modify the file. Then we’ll need to tell sed to delete the lines that contain the lower version number passing the flag -i will tell sed to modify the file in place.

~> find. -name "packages.config" | xargs grep -l FubuMVC\.References | xargs sed -i /FubuMVC\.Reference\..*722/d

Bam! I just modified 30 files without opening any of them…. Like I said its the best thing I’ve learned my entire career!

Herp it don’t Derp it!

-Ryan

Huboard is a kanban style drag and drop task board built entirely on top of the github api.

How to get started

Its easy. Go to any of your github repositories and add issues as you normally would. Next create some labels that represent your business process. For example, at Dovetail we use a simple workflow.

• 0 – Backlog
• 1 – Development
• 2 – Test
• 3 – Done

Notice the labels follow a pattern of ‘{number} – {title}’? The number represents the order you want your column to appear in your process and the title represents the header of the column. Huboard will automatically use the lowest number column as the hidden drawer column on the task board.

Move cards with git commits! weeeeeee

One of the coolest features of huboard is the ability to move cards through your process with git commit messages. You can create a post receive hook in huboard by clicking Setup at the top and create hook. This will add a commit hook into github so that huboard knows when you have committed code. Just put ‘pushes GH-5′ in your commit message and when you next push your changes up to github, Huboard will look for these commands and will move issue #5 into the next column in your process! Huboard also supports push, move, and moves as command names.

It’s open source!

That’s right! Huboard is open source hosted on github! And… Huboard uses huboard!

Sounds awesome, now tell me about the suck!

Huboard is in beta! (big surprise) Currently, it is open for everyone to use for free! We want to grow it slowly, which means we will be cutting off access after a certain amount of users to gauge how the site handles the traffic.

Huboard does not work in IE. Sorry we tried, we really did but we can’t figure out or debug the problems with IE. We !@#$ing hate IE

Issues have to be opened and closed on github.com, they are high on the backlog and coming soon! (in the mean time ‘gem install ghi’ and bask in the awesome that is command line issue creation)

Thats it!

Enjoy, feedback can be sent to @huboard. Issues and feature requests can be logged on github.

If you read my blog you should know by now that I am a big fan of reddit.com. There is a sub-reddit called r/circlejerk it not the most popular of sub-reddits but it is one of my favorites.

Lately there has been a lot posts about how Ruby on Rails might not follow the best practices. Which was followed up by a bunch of karma whoring / troll posts that don’t really help that much.

“Herp Derp: Hey… aren’t you doing the same thing?”

Yep! I bet my girlfriend this would make the front page.

.NET went through a similar movement not long ago called ALT.NET. To make a long story short, a lot of passionate, opinionated .NET developers started a bunch of blog posts, rants, and conferences trying to convince the “mainstream” .NET community that the Microsoft way was wrong and things like agile, IoC, TDD, and SOLID were the right way. We all know how the story ends, you guessed it a gigantic circlejerk. Why? Because much like r/circlejerk most of the people reading/writing the post are just in an echo chamber. The mainstream doesn’t care… They want more drag and drop fail sauce that’s even worse than ActiveRecord.

Don’t think you are immune Rails developers! Guess what Rails is more popular than ever and soon there is going to be a lot of “mainstream” Rails developers that just plain don’t care. Don’t let that be you! Don’t let it become a huge circlejerk called ALT.rb. Principles do matter.

I’ve got confidence that Rails will actually get better because of this, you’ve got guys like this

And sadly .NET’s got this guy

Never the less it’s out there and I’ve been told that it was a pretty good talk. Feel free to leave me some feedback anything I can do to make the talk better or more informative is greatly appreciated.

Video (flash): http://usergroup.tv/videos/conjunction-junction-what-s-your-function-javascript
Video (html5 fullscreen): http://www.screencast.com/users/UserGroupTV/folders/UGTV/media/9ca157f3-b93f-4f54-bd1d-8d8f6f0d657b/embed
Slides: http://hccjavascript.heroku.com

Big thanks to UserGroup.tv for publishing this video.

AMA definitely Derpin it in this video,

-Ryan