sudo apt-get install wordnet

Then simply type:

wn hello -over

You should see output similar to this:

Overview of noun hello

The noun hello has 1 sense (first 1 from tagged texts)

1. (1) hello, hullo, hi, howdy, how-do-you-do — (an expression of greeting; “every morning they exchanged polite hellos”)

That’s all well and good, until I typed this:

wn smote -over

And came up empty. Indeed WordNet is useful but it is limited. There are 2 solutions that immediately came to mind.

1. Figure out how to get more definitions loaded into my instance of WordNet
2. Find a dictionary service that is much more comprehensive than WordNet, and write a client for it

After a couple of quick Google searches I decided on the latter. And, since I’ve been doing a fair amount of Grails work lately, I thought, why not try this in Groovy?

One of those Google searches brought me to http://services.aonaware.com/DictService/. After a few trials with the simple front-end on the page, I was satisfied. Then it was time to find a Groovy example, which I found quickly enough with Groovy WS.

If you look at the code snippet on that page, it is incredibly simple.

@Grab(group='org.codehaus.groovy.modules', module='groovyws', version='0.5.2')
import groovyx.net.ws.WSClient

proxy = new WSClient("http://www.w3schools.com/webservices/tempconvert.asmx?WSDL", this.class.classLoader)
proxy.initialize()

result = proxy.CelsiusToFahrenheit(0)
println "You are probably freezing at ${result} degrees Farhenheit"

I tried this example as is, but seemed to have problems with the annotation at the top. Being rather impatient, I found a Groovy WS Standalone jar here at:
http://snapshots.dist.codehaus.org/groovy/distributions/groovyws/groovyws-standalone-0.5-SNAPSHOT.jar

I dropped it into my $GROOVY_HOME/lib directory, and then removed the annotation from the code. The example worked perfectly.

So, using the WSDL from the service I mentioned earlier, I made a few modifications and named it Pablo.groovy. Why Pablo? Why not? When speed counts, who cares?!

import groovyx.net.ws.WSClient

proxy = new WSClient("http://services.aonaware.com/DictService/DictService.asmx?WSDL", this.class.classLoader)
proxy.initialize()

//Define is a name of the service method, see the service WSDL
result = proxy.Define(args[0])

if(result != null) {
	for(defin in result.definitions.definition) {
		println "${defin.wordDefinition}"
	}
}

I needed to analyze the WSDL to figure out how to interpret the results, but other than that, it was a pleasantly pain-free experience.

Now I type:

groovy Pablo.groovy smote

And I get a much more satisfying result, save the logging garbage at the top!

Jul 18, 2011 5:11:29 PM org.apache.cxf.endpoint.dynamic.DynamicClientFactory outputDebug
INFO: Created classes: com.aonaware.services.webservices.ArrayOfDefinition, com.aonaware.services.webservices.ArrayOfDictionary, com.aonaware.services.webservices.ArrayOfDictionaryWord, com.aonaware.services.webservices.ArrayOfStrategy, com.aonaware.services.webservices.Define, com.aonaware.services.webservices.DefineInDict, com.aonaware.services.webservices.DefineInDictResponse, com.aonaware.services.webservices.DefineResponse, com.aonaware.services.webservices.Definition, com.aonaware.services.webservices.Dictionary, com.aonaware.services.webservices.DictionaryInfo, com.aonaware.services.webservices.DictionaryInfoResponse, com.aonaware.services.webservices.DictionaryList, com.aonaware.services.webservices.DictionaryListExtended, com.aonaware.services.webservices.DictionaryListExtendedResponse, com.aonaware.services.webservices.DictionaryListResponse, com.aonaware.services.webservices.DictionaryWord, com.aonaware.services.webservices.Match, com.aonaware.services.webservices.MatchInDict, com.aonaware.services.webservices.MatchInDictResponse, com.aonaware.services.webservices.MatchResponse, com.aonaware.services.webservices.ObjectFactory, com.aonaware.services.webservices.ServerInfo, com.aonaware.services.webservices.ServerInfoResponse, com.aonaware.services.webservices.Strategy, com.aonaware.services.webservices.StrategyList, com.aonaware.services.webservices.StrategyListResponse, com.aonaware.services.webservices.WordDefinition
Jul 18, 2011 5:11:30 PM groovyx.net.ws.AbstractCXFWSClient getBindingOperationInfo
WARNING: Using SOAP version: 1.1
Smite \Smite\ (sm[imac]t), v. t. [imp. {Smote} (sm[=o]t), rarely
{Smit} (sm[i^]t); p. p. {Smitten} (sm[i^]t”t’n), rarely
{Smit}, or {Smote}; p. pr. & vb. n. {Smiting}
(sm[imac]t”[i^]ng).] [AS. sm[=i]tan to smite, to soil,
pollute; akin to OFries. sm[=i]ta to smite, LG. smiten, D.
smijten, G. schmeissen, OHG. sm[=i]zan to smear, stroke, OSw.
& dial. Sw. smita to smite, Dan. smide to throw, Goth.
bismeitan, to anoint, besmear; cf. Skr. m[=e]d to be fat. The
original sense seems to have been, to daub on, to smear. Cf.
{Smut}.]
1. To strike; to inflict a blow upon with the hand, or with
any instrument held in the hand, or with a missile thrown
by the hand; as, to smite with the fist, with a rod,
sword, spear, or stone.
[1913 Webster]

Now to smote the logging and be rid of it; simply adding these few lines will do:

import java.util.logging.Level
import java.util.logging.LogManager

LogManager.getLogManager().getLogger("").setLevel(Level.SEVERE)

Now the output is as tidy as I want it to be for now.

$ groovy Pablo.groovy smote
Smite \Smite\ (sm[imac]t), v. t. [imp. {Smote} (sm[=o]t), rarely
{Smit} (sm[i^]t); p. p. {Smitten} (sm[i^]t”t’n), rarely
{Smit}, or {Smote}; p. pr. & vb. n. {Smiting}
(sm[imac]t”[i^]ng).] [AS. sm[=i]tan to smite, to soil,
pollute; akin to OFries. sm[=i]ta to smite, LG. smiten, D.
smijten, G. schmeissen, OHG. sm[=i]zan to smear, stroke, OSw.
& dial. Sw. smita to smite, Dan. smide to throw, Goth.
bismeitan, to anoint, besmear; cf. Skr. m[=e]d to be fat. The
original sense seems to have been, to daub on, to smear. Cf.
{Smut}.]
1. To strike; to inflict a blow upon with the hand, or with
any instrument held in the hand, or with a missile thrown
by the hand; as, to smite with the fist, with a rod,
sword, spear, or stone.
[1913 Webster]

Whosoever shall smite thee on thy right cheek, turn
to him the other also. –Matt. v. 39.
[1913 Webster]

And David . . . took thence a stone, and slang it,
and smote the Philistine in his forehead. –1 Sam.
xvii. 49.
[1913 Webster]

2. To cause to strike; to use as an instrument in striking or
hurling.
[1913 Webster]

Prophesy, and smite thine hands together. –Ezek.
xxi. 14.
[1913 Webster]

Saul . . . smote the javelin into the wall. –1 Sam.
xix. 10.
[1913 Webster]

3. To destroy the life of by beating, or by weapons of any
kind; to slay by a blow; to kill; as, to smite one with
the sword, or with an arrow or other instrument.
[1913 Webster]

4. To put to rout in battle; to overthrow by war.
[1913 Webster]

5. To blast; to destroy the life or vigor of, as by a stroke
or by some visitation.
[1913 Webster]

The flax and the barly was smitten. –Ex. ix. 31.
[1913 Webster]

6. To afflict; to chasten; to punish.
[1913 Webster]

Let us not mistake God’s goodness, nor imagine,
because he smites us, that we are forsaken by him.
–Wake.
[1913 Webster]

7. To strike or affect with passion, as love or fear.
[1913 Webster]

The charms that smite the simple heart. –Pope.
[1913 Webster]

Smit with the love of sister arts we came. –Pope.
[1913 Webster]

{To smite off}, to cut off.

{To smite out}, to knock out, as a tooth. –Exod. xxi. 27.

{To smite with the tongue}, to reproach or upbraid; to
revile. [Obs.] –Jer. xviii. 18.
[1913 Webster]

Smite \Smite\ (sm[imac]t), v. t. [imp. {Smote} (sm[=o]t), rarely
{Smit} (sm[i^]t); p. p. {Smitten} (sm[i^]t”t’n), rarely
{Smit}, or {Smote}; p. pr. & vb. n. {Smiting}
(sm[imac]t”[i^]ng).] [AS. sm[=i]tan to smite, to soil,
pollute; akin to OFries. sm[=i]ta to smite, LG. smiten, D.
smijten, G. schmeissen, OHG. sm[=i]zan to smear, stroke, OSw.
& dial. Sw. smita to smite, Dan. smide to throw, Goth.
bismeitan, to anoint, besmear; cf. Skr. m[=e]d to be fat. The
original sense seems to have been, to daub on, to smear. Cf.
{Smut}.]
1. To strike; to inflict a blow upon with the hand, or with
any instrument held in the hand, or with a missile thrown
by the hand; as, to smite with the fist, with a rod,
sword, spear, or stone.
[1913 Webster]

Whosoever shall smite thee on thy right cheek, turn
to him the other also. –Matt. v. 39.
[1913 Webster]

And David . . . took thence a stone, and slang it,
and smote the Philistine in his forehead. –1 Sam.
xvii. 49.
[1913 Webster]

2. To cause to strike; to use as an instrument in striking or
hurling.
[1913 Webster]

Prophesy, and smite thine hands together. –Ezek.
xxi. 14.
[1913 Webster]

Saul . . . smote the javelin into the wall. –1 Sam.
xix. 10.
[1913 Webster]

3. To destroy the life of by beating, or by weapons of any
kind; to slay by a blow; to kill; as, to smite one with
the sword, or with an arrow or other instrument.
[1913 Webster]

4. To put to rout in battle; to overthrow by war.
[1913 Webster]

5. To blast; to destroy the life or vigor of, as by a stroke
or by some visitation.
[1913 Webster]

The flax and the barly was smitten. –Ex. ix. 31.
[1913 Webster]

6. To afflict; to chasten; to punish.
[1913 Webster]

Let us not mistake God’s goodness, nor imagine,
because he smites us, that we are forsaken by him.
–Wake.
[1913 Webster]

7. To strike or affect with passion, as love or fear.
[1913 Webster]

The charms that smite the simple heart. –Pope.
[1913 Webster]

Smit with the love of sister arts we came. –Pope.
[1913 Webster]

{To smite off}, to cut off.

{To smite out}, to knock out, as a tooth. –Exod. xxi. 27.

{To smite with the tongue}, to reproach or upbraid; to
revile. [Obs.] –Jer. xviii. 18.
[1913 Webster]

Smote \Smote\,
imp. (& rare p. p.) of {Smite}.
[1913 Webster]

smite
v 1: inflict a heavy blow on, with the hand, a tool, or a weapon
2: affect suddenly with deep feeling; “He was smitten with love
for this young girl”
3: cause pain or suffering in; “afflict with the plague”; “That
debasement of the verbal currency that afflicts terms used
in advertisement” [syn: {afflict}]
[also: {smote}, {smitten}, {smit}]

smote
See {smite}

The results are lengthy, but for right now, it’s all that I want. And nay, I shan’t complain!

It was quick and easy, and as long as I use it less than several thousand times per day, I am operating well within the terms of service.

Till next time!

Then I found twittering-mode.el.

This is a cakewalk to install and use!

You simply need to follow the few basic instructions from the wiki here: http://www.emacswiki.org/emacs/TwitteringMode

When you run twittering-mode for the first time, you will be prompted to login to the twmode twitter app (via a browser). Enter your credentials and you will receive a pin, which you will then enter into the next prompt from the mode. The OAuth authentication requirements are satisfied by use of the twmode twitter app.

Easy peasy, as some of you would probably say.

UPDATE

To avoid repeatedly retrieving and entering a pin, you can store the encrypted tokens in a local file by enabling:
(setq twittering-use-master-password t)

At this time, you need to download the latest .el file (from the HEAD branch) in order to get this to work:
http://github.com/hayamiz/twittering-mode/raw/master/twittering-mode.el

Enter the mode and follow the prompts to set the master password.

Then, instead of needing to get and enter pins from the twmode twitter app, you simply enter the master password.

For more info on this, see http://github.com/hayamiz/twittering-mode/blob/master/NEWS.

Cheers!

So I figured, hey I know enough bash to at least get something rolling in order to do this. Of course I had to keep looking stuff up in reference guides and on websites, because there’s no way I can remember it all. Basically, it came down to 4 key tools for going the bash route.

1. sed – to strip brackets, slashes, colons, spaces, and other undesired characters in order to make the strings easier to deal with
2. awk – to find the location of decimal points or other characters
3. cut – to get characters to the left or right of decimal points
4. bc – to calculate and convert the milliseconds to human readable form

I finally got it to work reliably tonight.
It was a horrid process that took forever. What a waste of time. But hey, that’s all part of the RTC experience!
So here it is, please excuse the bad variable names and sloppiness. I was too pissed to give a ****.
Note: I renamed this to xmms2tracklensafe and cut out all the curse words and tried to put some sense into the comments.

#!/bin/bash
tmpfileinfo=xtemp14251.tmp
tmpfile=xtemp91839.tmp
#use xmms2 info here
xmms2 info > $tmpfileinfo
vargrep=$(grep "duration" $tmpfileinfo)
echo $vargrep > $tmpfileinfo
#chopping the brackets, slashes, and spaces out of the string
sed -i 's/\[//g' $tmpfileinfo
sed -i 's/\]//g' $tmpfileinfo
sed -i 's/\///g' $tmpfileinfo
sed -i 's/'\ '//g' $tmpfileinfo
#convert the = to an X, easy to find
sed -i 's/\=/X/g' $tmpfileinfo
#for an mp3 - pluginmaddurationX
sed -i 's/\pluginmaddurationX//g' $tmpfileinfo
#for a flac - pluginflacdurationX
sed -i 's/\pluginflacdurationX//g' $tmpfileinfo
#God knows what other codecs there might be
#prints the time in milliseconds
echo "$(cat $tmpfileinfo) ms"
vargrep2=$(cat $tmpfileinfo)
varx=$vargrep2
#convert the time to minutes
var2=$(echo "$varx/1000/60" | bc -l)
echo $var2 > $tmpfile
#we are left with a fraction of a minute, which occurs after the decimal, we need to find the decimal point
var3=$(awk 'BEGIN { print index('$var2', ".") }')
#get the characters after the decimal point, this is our fraction of a minute
var4=$(cut -c $var3- $tmpfile)
#convert that fraction of a minute into seconds
var5=$(echo "scale=1; $var4*60" | bc -l | xargs printf "%1.0f")
#simply subtracting a 1 from the index of the decimal point, to be used in order to retrieve the number left of the decimal
varcut=$(echo "$var3 - 1" | bc -l | xargs printf "%1.0f")
#gets the number to the left of the decimal
var6=$(cut -c -$varcut $tmpfile)
#now we need to deal with the decimal in the number that has been converted to seconds
var7=$(awk 'BEGIN { print index('$var5', ".") }')
varcut2=1
#I honestly don't remember why I did this.  I think I needed it before I started adding | xargs printf "%1.0f"
if [ "0" != $var7 ]
	then
		varcut2=$(echo "$var7 - 1" | bc -l | xargs printf "%1.0f")
fi

echo $var5 > $tmpfile
#now we get the seconds as a whole number, by getting the characters left of the decimal
var8=$(cut -c -$varcut2 $tmpfile)
var8=$(cat $tmpfile)

#need to prepend a 0 to the seconds if they are under 10
if [ $var8 -lt 10 ]
	then
		var8="0$var8"
fi

#print out the time in human readable form, minutes : seconds
echo "$var6:$var8"
#clean up the temp files
rm -f $tmpfile
rm -f $tmpfileinfo

Wow, what a pain in the pee-hole. It took me several hours over two nights and I even lost some sleep over it. So, I decided to try it Jeff’s way, using Python, since he brags about it so much. I had never used it before, and now that I have, I think I’ll be using it a lot! A lot of you are saying, “Well yeah, duh. Idiot.” or something more insulting, and I fully accept that. In fact, I encourage it!

First, we have the simple bash script that is used to execute the entire process from the command line.

#!/bin/bash

tmpfile=assscrambler124524.tmp
xmms2 info > $tmpfile

python ~/scripts/xmms2len.py

rm -f $tmpfile

And now we have the giant, complex, and horrendous python script.

file = open('./assscrambler124524.tmp')
for line in file:
	if(line.find('duration',0) > -1) :
		#print(line)
		s = line
		searchstr = 'duration = ';
		x = s.rindex(searchstr, 0);
		if(x > -1):
			timeMillis = s[x+len(searchstr):len(s)].strip()
			#print(timeMillis)
			timeConverted = float(timeMillis)/1000/60
			#print(timeConverted);
			stime = str(timeConverted)
			decIndex = stime.rindex('.', 0)
			timeFraction = float(stime[decIndex:len(stime)])
			seconds = int(round(timeFraction*60,0))
			strseconds = str(seconds)
			minutes = stime[0:decIndex]
			strminutes = str(minutes)
			if(seconds < 10) :
				strseconds = '0' + str(seconds)
			print(timeMillis + ' ms\n' + str(minutes) + ':' + strseconds)
			break

Wait, that's it? Just some simple searches, substrings, calculations, easy conversions between types, and that's all? Not to mention the incredibly easy way to open a file and iterate through its lines.
Now, I commented out some print statements here, and I could have compacted it more, but I wanted it to be reasonably clear. The point of course, and 95% of you know probably know this already, is that python kicks bash's ass when it comes to things that should be, well, programs. Of course bash scripts will always have their place, and they are necessary for so many things. I still love bash and am very fond of it, but from a programming perspective, it just doesn't "cut the mustard", as Jeff would say.

Well, that's it for my exciting Friday night. Someday I'll get my crap together and talk more about my xmms2 setup, the xmms2 python equalizer, the xmms2 scrobbler for last.fm, and the other scripts I've written for xmms2.

Cya!

My main reference for python: http://www.astro.ufl.edu/~warner/prog/python.html


#!/bin/bash

echo $WORD > $TEMPFILE
aspell -c $TEMPFILE
cat $TEMPFILE
rm -f $TEMPFILE
rm -f $TEMPFILE.bak


I named this script “spell”. Simply use it like so:

$ spell reccomend


Aspell will run and you can make your changes.

reccomend

1) recommends 6) commend
2) recommend 7) recommenced
3) reckoned recommended
4) regiment 9) Redmond
5) recombined 0) rejoined
i) Ignore I) Ignore all
r) Replace R) Replace all
a) Add l) Add Lower
b) Abort x) Exit


In this case, if I type “2″, the correction will be made, aspell will exit and the spelling I chose gets printed out.

Here’s an example of how to use it with a sentence.

$ spell "I go to the storede and buy beakh clotes"


Now aspell will take you through each misspelled word. After you finish the corrections it will exit and print out the corrected sentence or series of words.

I go to the store and buy beach clothes


http://www.twitter.com/reverttoconsole

What’s needed (for a poor windows user):

• Mcabber, a jabber client from http://mcabber.com
• Cygwin, http://cygwin.com
• Ssh package for cygwin, if you need to install mcabber elsewhere and then connect to it remotely.

If cygwin and ssh are new to you, read this to get up to speed.

If you are setting up mcabber on a host machine, you’ll want to setup ssh as a service or daemon on that machine as well. Use the ssh-host-config script to do that.

Quickly, here’s how to get going.

1. Get the latest updates for cygwin using the cygwin setup program. I was missing the latest glib and I didn’t have pkg-config.
2. Download the mcabber source from the website. Run the configure script with no arguments. Take note of any errors; they are most likely related to missing libraries. Get these libraries with the cygwin setup program.
3. Once configure is successful, you should be able to run make, and then make install with no problems.
4. Create a mcabberrc file in the directory ~/.mcabber, note that the filename is “mcabberrc” and not “.mcabberrc”.
5. Put the following into the mcabberrc file to configure it for Google Talk.

set username = <your username at gmail dot com>
set server = talk.google.com
set ssl = 1
set ssl_verify = 0
set port = 5223

That’s all there is to it. Type mcabber and it should prompt you for your password and then connect.

You’ll see 3 different “panes” or frames and the command prompt at the bottom. Scroll through your contacts with Page Up and Page Down. When you’ve selected a contact, just start typing in the command prompt to send messages. The program commands start with a “/” character, type “man mcabber” for a complete list of commands. If you’re in mcabber, you can type “/help” for help on specific mcabber commands.

That’s all for now!

-eokuwwy

The answer is YES!

The Translate Word and Graphical TW project is your gateway to having superior translation capabilities right in your CONSOLE!

Download tw from http://savannah.nongnu.org/files/?group=twandgtw.
I’m using tw-0.1.3.tar.bz2.

Major Dependencies
elinks
http://elinks.or.cz/download
I’m using elinks-0.11.5.tar.bz2.

I’m using Cygwin and I was missing the following:
curl
libiconv
util-linux random utils (For the getopt() function)

The above Cygwin packages can easily be obtained through the Cygwin setup program.

1. Extract elinks. Build it starting with “sh configure”. Then type “make”. After it finishes, type “make install”.

2. Repeat step 1 with tw.

3. Type “tw -h” to test that everything is installed correctly.

4. If everything went well, try typing “tw en-es hello” and you should get the following output:
hello : hola

You’re all set! Now you can quickly translate between many languages straight from your bash shell. Type “tw -l” to see a list of “all” the languages.

Customized Script for Google Translate

Google’s translate service is one of the most comprehensive language translators available. A major benefit of using Google’s translation service is that you can pass in as much text as you want; simply surround the text with quotes. Even though tw does not list all of the languages that Google supports, it is still a bash script that parses input parameters, and it does not do any validation. You can append anything you want to the argument “translate.google.com”. For instance, Croatian is not listed as one of the languages (“hr”). However, all you need to do is append the appropriate language pair to the end of the argument string, like so:
$ tw translate.google.com.en-hr hello
zdravo

To make this a bit more user-friendly, I have created a simple wrapper script (twg) for tw that only uses Google’s translate service. It works just like tw, except you do not have to type “translate.google.com”. You only need to put in the language pair. For example:
$ twg en-es “Hello World”
Hola Mundo

Type “twg -l” to get a complete list of supported languages. You can find more details about featured languages at http://www.google.com/help/faq_translation.html#langpairs.

#!/bin/bash
# author: eokuwwy
# http://reverttoconsole.com
# description: customized tw wrapper script that uses google translate</code>

if [ "$1" = "-l" ];
then
echo "Arabic=ar";
echo "Bulgarian=bg";
echo "Catalan=ca";
echo "Chinese=zh-cn";
echo "Chinese=zh-tw";
echo "Croation=hr";
echo "Czech=cs";
echo "Danish=da";
echo "Dutch=nl";
echo "English=en";
echo "Filipino=tl";
echo "Finnish=fi";
echo "French=fr";
echo "German=de";
echo "Greek=el";
echo "Hebrew=iw";
echo "Hindi=hi";
echo "Indonesian=id";
echo "Italian=it";
echo "Japanese=ja";
echo "Korean=ko";
echo "Latvian=lv";
echo "Lithuanian=lt";
echo "Norwegian=no";
echo "Polish=pl";
echo "Portuguese=pt-BR";
echo "Romanian=ro";
echo "Russian=ru";
echo "Serbian=sr";
echo "Slovak=sk";
echo "Slovenian=sl";
echo "Spanish=es";
echo "Swedish=sv";
echo "Ukranian=uk";
echo "Vietnamese=vi";
elif [ "$1" = "-h" -o -z "$1" ];
then
echo "Usage: twg [sourcelang-destlang (i.e. en-es)] [term]";
echo "twg -h (shows help)";
echo "twg -l (shows language list)";
else
tw translate.google.com.$1 "$2";
fi

Happy command line translation! Now jailbreak (at your own risk) your iPhone/Blackberry/PDA and put tw on there!

$ twg en-es “peace out”
a la paz
-eokuwwy

However, some of you may benefit from what I have learned NOT to do over the past 2 years. I have learned plenty of “DO NOT’s” over time, but the last 2 years, especially the last 7 months has been the grand festival of “DO NOT’s”.

1. Do not let an “expert” with unsubstantiated credentials tell you how to do your job. Better yet, avoid working with an “expert” whenever possible. These “experts” like to talk down to you and blame you for everything that goes wrong. They never admit to contributing to the problem. They also insist that his/her approach is the best, even if God (or other supreme being) were to tell him/her that it’s wrong. An “expert” will try to control you and the project at any cost. An “expert” will no doubt run the project into the ground or into a persistent vegetative state. If you find yourself working with an “expert”, take precautionary measures and have an escape plan.

2. Do not let users perform their daily job duties with an application that is not fully developed or production ready, especially if it’s not even beta ready. Don’t let users rely on an application that is undergoing constant development and hasn’t even been tested. Users will no doubt work their dirty little hands into your project and get you to make changes at the drop of the hat, because their jobs depend on it! Don’t expect a manager to help you out in this situation. If things have reached this point, no manager can simply stop this evil cycle. Now you have a situation where there is a direct impact on the success of the company. Because the application is not even fully developed or tested, there will already be bugs galore. The users relying on your application will find even more bugs that stop them in their tracks. Everything becomes a critical defect. Trust me, if you get into this situation, you will want to die, because you are already dying a slow and painful death.

3. Do not develop in an environment that has absolutely no process. You don’t need to be process gung-ho and implementing CMMi level 5, but you should have some basic sort of SDLC process in place. A development group without processes usually fails to have standards as well. The “as long as it works” mantra comes into play.

In this situation, you will end up with horrible spaghetti code where developers are doing whatever the hell they want. You will have no ability to monitor code quality. You might end up with code that looks like it was written by someone who is half-way through their first programming course (CSCI 101). Hey, they just learned how to write arrays, and want to show off that skill, as much as they can. Your “code review” will take place when you have to take over their project, at which point you’ll ask yourself, “What kind of dumbass could possibly write this &*@%!@#!!!????” Of course by then the bad code has permeated its way into the deep inner bowels of the application, like a virus, making it nearly impossible to correct without throwing it all away and rewriting from scratch. It’s sort of like when Windows gets jacked-up every year or so and your best solution is to “format C:” and start over.

In addition, the extent of your QA will probably be limited to the success of your compiler and a few keystrokes and mouse clicks.

no process = bad applications (hopefully most of you know that already)

4. Do not get involved in a project where a phone call, simple face-to-face conversation, or a note on your desk from a user is all that is required for you to make a change. This is closely related to #3, but it’s worth emphasizing a bit. You need to have a way to document change requests and prioritize those requests, even if it a simple excel spreadsheet on a shared network drive. This is just one more way that you can be trampled to death by users. Not to mention the fact that you are developer and you have no business answering the phone or communicating with a user directly. That’s what BA’s are for. You lack the people skills required to interact directly with users and you should be damn proud of that. Additionally, there is great satisfaction to be had when you can make users punch themselves in the face. By that I mean something like this:

User: “What is this thing doing? That’s not the way it’s suppose to work!”
You: “Yes it is.”
User: “No, it’s not.”
You: “Yes it is, you requested it, see?”
User: “Ah DAMMIT!” (punches self in face)

5. Do not succumb to the “at least we still have jobs” outlook on your career. Yes, the economy sucks right now and layoffs suck. I hate seeing people bringing in boxes to pack up their stuff, especially when they have done a great job at the company for 10, 15, 20 years or more. That’s like saying, “Thanks for all your great years of service, now be a team player and piss off, yeah?” There are other things employers will do to cut costs though. They might squash benefits, slash salaries, and eliminate incentives. This is especially likely to happen if the executives made stupid decisions (likely in any case) that ran the company into the ground. You don’t have to pay for their mistakes. This industry is still viable. You can find good opportunities elsewhere. Don’t be afraid to explore and don’t feel bad for leaving. If you really believe in the company and feel that you want to help “get through this tough time together”, then stay and try to maintain a positive attitude. But remember, you don’t owe the company anything.

That’s it for now. Maybe you learned something, maybe not. You may have only learned that I am just an ass, if you didn’t know that already. Either way, I hope it wasn’t a boring read. I’d better get back to “work.”

*RRRRRRRRRRRRRRRRRRRRRRRIIIIIIIIIIIING*
Me: “Hello”
SU: “Why is the application going so incredibly slow?”
Me: “Because I coded it so that if it finds your user ID it will run slower.”
SU: “I’m reporting you to HR!”
Me: “OK, but you’ll be wasting your time.”
SU: “And why is that?!”
Me: “Because I told everyone in HR that you are a stupid b*tch.”
*click*

The user is not “the enemy”, nor is the user “stupid”. Without users, there is no software. Users are simply human beings. Their minds are not bound by physical limits, such as volts, amps, or aerodynamic drag. A human’s mind is capable of dreaming up anything, whether it is possible or not in the physical world. In software we operate within a virtual world not bound by earthly physics. This fact combined with the vast imagination of the human mind is what makes software development so challenging. Without boundaries and limits, you can easily find yourself in a no holds barred situation.

Therefore, it is imperative that developers impose and enforce boundaries upon the user. There are many examples of this: change control boards, requirements sign off, iterative development, etc. While these conventional measures serve their purpose, it is sometimes necessary to take extra steps that may be ethically questionable.

You need to know the following:
1. The user does not really know what he/she wants
2. The user needs to be told what he/she can and cannot have
3. You are in control of the software, not the user
4. You are the technical expert, not the user
5. The user doesn’t care about how the software works, so long as it works

We should not feel guilty about the nature of software development, nor the ways in which we deal with the above facts. To deal with those facts mentioned above, consider the following:
1. Lead the user away from ideas that will result in requiring complex features, while persuading them to accept ideas that will require simpler ones.
2. Be firm with what features can and cannot be built. Remember, the user is not the technical expert. You can bend the truth a bit with your imagination and technical knowledge.
3. Do not ever give control of development to the user. Always require him or her to follow proper procedures for change requests, it doesn’t matter how “urgent” it is. Unless there is a defect causing people to die or the company to lose massive amounts of money, it is not urgent enough to skip the procedures and processes that have been put in place.
4. Do not be fooled by a user who claims to be an expert as a software developer. Unless they are working on the same software that you are, their “knowledge” is useless. Users with strong educational backgrounds love to make these claims. (i.e., M.D.’s, P.h.D.’s) Do not be intimidated. Have confidence in yourself and your abilities. If they are persistent about injecting their own technical “expertise” into your project, do whatever it takes to take them out of the picture. Get his/her manager involved if you have to. If you give in to this type of user, you could very well be jeopardizing the health of your entire project.
5.The user doesn’t care about how the software works so don’t tell him/her. Not only is it a waste of time, but it also keeps them in the dark. That allows you to bend and manipulate the technical truth to your liking if need be.

The last issue I would like to mention is the issue of deadlines. You should set these, not the user. If the user requires a deadline that is not reasonable, then tell him/her you will have to drop features in order to meet that deadline. You cannot give up control. Lie, cheat, and steal if you have to. I can’t really see where you’d have to do the latter, but I am serious here. Do whatever it takes to maintain control.

Again, the user is not the enemy (except maybe those “experts” described in number 4 above). The user just needs stringent boundaries and limits. These boundaries need to be firmly enforced, even if it means engaging in questionable tactics at times. Sometimes you may have to approach your job like you are a slightly less than honest politician. The end result will always be worth it. If you can keep the user in line, you will find your job to be much more rewarding.