Good recruiters look for people to fit a position, and pursue them individually. I’ve mentioned before that my name and resume pop on Google search results when a recruiter is looking for a senior web architect or development manager in the Seattle area. The best experiences I have ever had with recruiters come from these approaches, and they are instantly distinguishable from the usual.

One recruiter, Shannon Anderson from NuWest Group out of Bellevue, personifies this approach. She’s professional, spectacular at her job, and rarely presents more than a single candidate for a job. She matches people perfectly, and as a result, she gets a near perfect return on her investment and an ongoing relationship. It’s more like talking to a very friendly and competent matchmaker, and I’d encourage anyone to work with her or someone like her.

She makes personal connections, and takes her time getting to know her candidates.

Other great recruiters have a large database of positions, and instead of matching a candidate to a job, they match a job to a great candidate. Tara Gowland runs Startup Recroot, a Seattle-based firm, and her approach is to find spectacular and competent people, and try to pair them with positions that she’ll seek out. Her approach to me was diffident, even shy, which was a refreshing change from the normal TRUMPETS BLARING approach.

Now, while I can recommend each of these firms, and most specifically these two recruiters, I can’t tell you about the positions for which I was either hired or interviewed, since that breaks some confidentiality agreements. However, if you find recruiters like these ladies, I heartily recommend that you not only work with them, but that you give them all the social media and blogging help you can. Firms that are ethical, helpful, and who have recruiters with personal and competent approaches are few and far between.

Find these firms, and work with them. They’re full disclosure, honest, and they’re great at what they do. Please feel free to leave other firms that you’ve been happy to work with in the comments.

Recruiting must be the most outsourced, underfunded, middleman-heavy profession there is. There are several frustrations that go along with being heavily recruited by people who do not know or care whether you fit a given job description, and they range from the merely careless and time-profligate to the truly unethical.

(1) CARELESS: Recruiters who mass email everyone on CareerFinder and Monster with the word “Ruby” in their profile for an Austin, Texas-based junior web developer 3-month contract gig specializing in Ruby on Rails.

I am not a Ruby developer, I will not move to Austin, Texas, especially for a three month contract, and I’m not a junior ANYTHING. I have some skills with Ruby, meaning that I can install the necessary scripts, edit them, run them to operate a site, and I know enough to know when I need to call a specialist. This makes me able to list Ruby as a general low-level skill on my resume, but does not in any way qualify me for a development job on a site that solely uses Ruby for an environment. However, that keyword hits big with recruiters, and I get probably 15 emails a day from recruiters trying to get me to take a job for which I am unqualified and in a location to which I would not move. A simple glance at my resume with the words “Senior Development Manager and Web Architect” emblazoned across the top and a brief scan of my skillset tells anyone I am a skilled coder who has been moved up the chain to management, and would likely help those recruiters to target me far more efficiently.

(2) CARELESS: Recruiters who speak such poor English that their emails are unreadable–and that sometimes includes native English speakers.

I am glad that you’re “pleased for making time and hoping you will be helping me networking to fill VERY IMPORTANT positino immediatly in NEW YORKCITY as JAVA DEVELOPAR” [not a joke; I seem to be perpetually emailed by the recruiter version of Paul Christoforo], but I don’t need it filling my day. At the very minimum, have your job posts reviewed for content and grammar before sending them to thousands of developers.

(3) UNETHICAL: Recruiters who are paid by the emails they generate, not by the positions they fill.

This is a common problem among firms that have outsourced to the Philippines, India, Bangladesh, Malaysia…in fact, name your popular outsourcing destination in Asia, and you’ll find these recruiters, who are paid to send out as many emails as possible. They’re no better than spam, but because they’re targeted to you and have your email address, you can’t filter them the way you would filter a Cialis or pr0n ad.

(4) CARELESS: Recruiters who have not paid attention to your preferred location–and don’t care.

I will not take a job in South Dakota; I’m sorry. I’ve lived in several midwest states and think that South Dakota is quite eerily beautiful. I will not be transferring my life, my career, and my love of well-produced opera to Sioux Falls any time soon.

(5) UNETHICAL: Recruiters who expect you to do their job for them.

My final post will be the most egregious example I’ve found, combined with a horrific example of #6. The most common variety is this:

——————————————————————————————-
To better represent you, kindly fill out the skills inventory below. Thank you

1) Agile/Scrum (Beginner/Intermediate/Expert) (Years of experience/Date Last used)
2) Software Development Proj Mgmt (Beginner/Intermediate/Expert) (Years of experience/Date Last used)
3) Web-Based Application architecture knowledge (Beginner/Intermediate/Expert) (Years of experience/Date Last used)
4) Test Driven Development / XP (Beginner/Intermediate/Expert) (Years of experience/Date Last used)
5) Java development principals (Beginner/Intermediate/Expert) (Years of experience/Date Last used)
6) Release Management (Beginner/Intermediate/Expert) (Years of experience/Date Last used)

——————————————————————————————-

Remember that I get about 50 or so of these emails per day; this person doesn’t even want to read my resume, and instead wants me to fill out his paperwork for him. Note: this was for a position in California, making it irrelevant anyway.

(6) UNETHICAL: Recruiters who expect you to prep and interview with no information about the company.

This is the worst one. How can I know if I want to take a position if I’m not told: (1) what the salary will be, (2) where the company is physically located, (3) what benefits are available, and (4) to whom I would be reporting? This is just another version of wasting my time. I don’t talk anymore to recruiters who are secretive; they are occasionally fronts for disreputable companies who want a chance to sell you before you find out what their online reputation looks like.

Next, the traits of successful recruiters.

I’ll be speaking as a joint guest of the Ignite program through Seattle Public Schools and the IT department at SCCC.

People of all ages who want to know more about becoming a female programmer and entering technical careers are welcome to attend; I’ll be speaking on interview techniques, what to expect from your colleagues, how to succeed, and the rewards of software and web development compared to many traditional women’s career paths.

Please let your friends and mentees know; I am looking forward to answering your questions and giving you the insider information you need to succeed!

Tarah Wheeler Van Vlack, the Cowgirl Coder, to speak at SCCC 01/18/12 3-5PM

In an economic downturn, this may sound like what I call a ‘high-class problem.’ Noted examples of high-class problems include: paying taxes on your lottery winnings, being unable to make up your mind between your Harvard and Yale college acceptance letters, and getting a shopping cart dent in your Rolls Royce.

It may sound like I should have absolutely no problem finding my next contract or FTE position, but the truth is that I am bewildered by the sheer quantity of irrelevant job postings and shady headhunters by which I am besieged on a weekly basis. This is no joke: I have hired a remote assistant whose sole job for me is to go through all my emails related to job postings. I have no way to process them all and still get coding, blogging, eating, and living done. I have an obligation to follow up on each posting that fits my skill set, and I am trying my best to do so…but there’s no way to spend hours per response following up on thousands of postings–99.7% of which are irrelevant due to location, skill set, or compensation level.

Then, we come to the issue of rude and unethical recruiters. I’ve had some recent encounters that inspired this series; I’ll be describing that situation as I discuss the ethics of recruitment from the other side–the people being recruited. I’m bombarded by recruiters who have the incentive to email as many people as possible, since they have no reason to care about the skill sets or fit of the people they’re slotting into jobs. They’re paid by the number of people they place, not the quality of the placement or its duration. That doesn’t add up to a recruitment culture of individualized attention and courtesy. I’m also constantly hit by emails demanding my time and effort without so much as a ‘please’ and ‘thank you.’

Finally, there are rules that good recruiters follow which instantly get my attention and cause me to work with them. I’ll let you know what traits a recruiter possesses to make me work with them again and again.

So, over the next several days, I’ll be posting a multi-part series on how to recruit me. I want to be hired; people certainly want to hire me–so why is it so hard to be paired with a recruiter who has actually read my resume and thinks I’d be a great fit for their open position?

Welcome to the joy of being heavily recruited by thousands of clueless and careless headhunters who have your email address and phone number.

One of the things we all do in my gaming group is write our own dice rollers; rolling actual dice is SO passé–and there’s an ongoing argument about whether or not a seeded random is more or less random than the natural flaws in dice and rolling surfaces. Java is the language in which I learned to write math, so I somewhat naturally write algorithms in Java without thinking. It’s easy enough to translate this into C# or whatever.

Ok, so, here’s the algorithm. In Earthdawn, dice rolls are predicated on the step level of the difficulty. You may have an attack roll at step 18 and a damage roll at step 22. In 3rd edition Earthdawn, that translates to rolling d12+d10+d8 to attack, and 2d12+2d6 for damage. Here’s the chart (click to embiggen):

As you can see, there’s some kind of progression here; it turns out that the algorithm is a simple infinite series. There’s a jump in the number of dice every seven steps. Hence, the algorithm has a few simple steps:

(1) Divide the step number by 7.
(2) Determine and store the floor and the modulus.
(3) Roll a number of d12s equal to (floor – 1).
(4) Roll dice equal to the corresponding modulus (the first addition of dice past the 7 threshold will be 2d6, so if the modulus is 1, 2d6 are rolled and added).

That is the step algorithm such that no lookup is now necessary; Earthdawn has exploding dice and epic fails, however, so two things are necessary. Look at the exploding dice method; if you roll the maximum value of a die, you can roll it again. You can keep rolling that die until a value shows that is less than the maximum value, such that a d6 rolled with a result of 6 can be rerolled. On the second roll, 6 results. On the third roll, 2 results, so the total value of that die roll is 14. For epic fails, if you roll more than one die and all dice show ones, you have epically failed (similar to a fumble in D&D, and with equivalent disastrous results).

Here’s my dice roller; click to embiggen:

So, here’s the code. It’s intended to be self-contained (you can see that I use a pic of Captain Malcolm Reynolds; just drop a pic in your file structure and reference it in the code if you want a background). Obviously this is bare-bones; you can adapt it at your leisure and to whatever GUI you desire. Any suggestions are welcome; I am always debugging this (and the JavaScript I’m using to display syntax highlighting is a little cranky, so forgive any indentation issues). If you can think of a way to optimize this algorithm, let me know; I always need bragging rights over the guys

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242

package dice;
 
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
 
import javax.swing.BorderFactory;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JSpinner;
import javax.swing.JTextField;
import javax.swing.SpinnerModel;
import javax.swing.SpinnerNumberModel;
 
@SuppressWarnings("serial")
public class ImagePanel extends JPanel implements ActionListener{
 
	int six = 6;
	int eight = 8;
	int ten = 10;
	int twelve = 12;
	int dice = 0; //counter for total number of dice
 
	public int middle; //step value entered by me.
	public boolean fail; //whether or not an epic fail happened.
	public JFrame frame;
	public Random r;
	Image img = new ImageIcon("img/MalcolmReynolds13.jpg").getImage();
	SpinnerModel stepEntry = new SpinnerNumberModel(1, 1, 300, 1);
	SpinnerModel karmaCounter = new SpinnerNumberModel(25, 0, 25, 1);
	JSpinner stepSpinner = new JSpinner(stepEntry);
	JSpinner karmaSpinner = new JSpinner(karmaCounter);
 
	private JTextField diceResult;
	private JButton myButton;
	private JCheckBox myCheck;
	private JLabel enterStep = new JLabel("Enter Step Here.");
 
	public static void main(String[] args) {
		ImagePanel panel = new ImagePanel(new ImageIcon("img/MalcolmReynolds13.jpg").getImage());
		JFrame frame = new JFrame("Tarah's Dice Roller Of Awesomeness");
 
			frame.getContentPane().add(panel);
		    frame.pack();
		    frame.setVisible(true);
	}
 
	public ImagePanel(String img) {
		this(new ImageIcon(img).getImage());
	}
 
	public ImagePanel(Image img){
		this.img = img;
		Dimension size = new Dimension(img.getWidth(null), img.getHeight(null));
		setPreferredSize(size);
		setMinimumSize(size);
		setMaximumSize(size);
		setSize(size);
		JPanel panel = new JPanel();
		add(panel, "Center");
		myButton = new JButton("Roll The Dice.");
		myButton.addActionListener(this);
		myButton.setBorder(BorderFactory.createLineBorder(Color.black));
		diceResult = new JTextField("Roll Result", 9);
		diceResult.setBorder(BorderFactory.createLineBorder(Color.black));
		myCheck = new JCheckBox("Use Karma.", false);
		myCheck.setBorder(BorderFactory.createLineBorder(Color.black));
		GridLayout myGrid = new GridLayout(3, 2);
		panel.setLayout(myGrid);
		panel.setBorder(BorderFactory.createLineBorder(Color.black));
		panel.add(enterStep);
		panel.add(stepSpinner);
		panel.add(myButton);
		panel.add(diceResult);
		panel.add(myCheck);
		panel.add(karmaSpinner);
		setVisible(true);
	}
 
	public void paintComponent(Graphics g) {
		g.drawImage(img, 0, 0, null);
	}
 
	public void actionPerformed(ActionEvent e) {
		boolean useKarma = false;
		middle = (Integer)stepSpinner.getValue();
		System.out.println("actionPerformed() thinks the step number is: " + middle);
		if (myCheck.isSelected() == true) {
			System.out.println("Using Karma.");
			useKarma = true;
			int decrease = ((Integer)karmaCounter.getValue()) - 1;
			karmaCounter.setValue(decrease);
		}
		String s = Integer.toString(rollTheDice(useKarma, middle, fail));
	    diceResult.setText(s);
 
	} 
 
/////////////////////////////////////////////
/////////////////MATHYNESS///////////////////
/////////////////////////////////////////////
 
	//This is the Earthdawn Exploding Dice Method.
	public int d (int die){
 
		int sides = die;
		int result = 0;
        int roll;
 
		do {
			r = new Random();
            roll = r.nextInt(sides) + 1;
            result = result + roll;
            System.out.println("This is a d" + sides + " roll with result: " + result);
       } while (roll == sides);
 
		return result;
	}
 
	public int oneToSeven (int o) {
		int result = 0;
		if (o == 1) {
			result = d(six) - 3;
			if (result < 1) {
				result = 1;
			}
		}
		if (o == 2) {
			result = d(six) - 2;
			if (result < 1) {
				result = 1;
			}
		}
		if (o == 3) {
			result = d(six) - 1;
			if (result < 1) {
				result = 1;
			}
		}
		if (o == 4) {
			result = d(six);
		}
		if (o == 5) {
			result = d(eight);
		}
		if (o == 6) {
			result = d(ten);
		}
		if (o == 7) {
			result = d(twelve);
		}
		return result;
	}
 
	public int prefix (int p) {
		int prefixTotal = 0;
 
		for (int i=1; i<p; i++) {
			prefixTotal = prefixTotal + d(twelve);
			dice++;
		}
		return prefixTotal;
	}
 
	public int suffix (int s){
		int suffixTotal = 0;;
		if (s == 1){
			suffixTotal = d(six) + d(six);
		}
		if (s == 2){
			suffixTotal = d(eight) + d(six);
		}
		if (s == 3){
			suffixTotal = d(eight) + d(eight);
		}
		if (s == 4){
			suffixTotal = d(ten) + d(eight);
		}
		if (s == 5){
			suffixTotal = d(ten) + d(ten);
		}
		if (s == 6){
			suffixTotal = d(twelve) + d(ten);
		}
		if (s == 0){
			suffixTotal = d(twelve);
		}
		return suffixTotal;
	}
 
	public int step (int sn){
		int result = 0;
		fail = false;
 
		int full = sn / 7; //will yield the d12s
		int mod = sn % 7;  //will yield the additive dice
 
		if (sn < 8) {
			int total = oneToSeven(sn);
			result = total;
		}
		if (sn >= 8) {
			int d12s = prefix(full);
			int rest = suffix(mod);
			result = d12s + rest;
 
			if (result == full+1) {
				fail = true;
			}
		}
		return result;
	}
 
	public int rollTheDice(boolean addKarma, int stepValue, boolean epicFail) {
		boolean addK = addKarma;
		dice = 0;
		int result = 0;
		result = step(stepValue);
		epicFail = fail;
		if (addK == true) {
			int dK = d(six);
			result = result + dK;
			if (epicFail == true && dK == 1) {
				JOptionPane.showMessageDialog(frame, "Epic FAIL.");
			}
		}
		else if (addK != true && epicFail == true) {
			JOptionPane.showMessageDialog(frame, "Epic FAIL.");
		}
		return result;
	}
}

My resume isn’t perfect.

There are three companies I’ve been dealing with over the last five weeks who were all based in multiple countries. I never thought to add my multiple language proficiencies to my resume; I have a hard time keeping my resume under four pages as it is, and that’s with leaving off references and most of my educational qualifications.

However, I’m near-fluent in French, quite good in German, and have a serious background in Mandarin, Spanish, Greek, and a smattering of a half-dozen other languages. I was coaching a female developer three weeks ago who was applying to a company with multiple locations worldwide–including Latin America, and never thought to tell her that her proficiency in Spanish should certainly come up during her interview.

As companies start to expand and acquire, you may find that your four years of German (no matter how rusty) can pay off. If you’re proficient in an Asian language, make sure it shows up on your resume in the skills section. If you speak Klingon, email me. I need a translation of Jabberwocky for an ongoing joke I have with my father.

Oh, wait.

Tech Interview Help

So, this isn’t an entirely disinterested post, but I do want to add some information for you.

One of the best things you can do to prepare for interviews is to actually dev with the SDK and API that the company produces. I am in the Seattle area, and if I had an interview with Amazon S3, the first thing I’d be doing is setting up a bucket (not that I haven’t already done fifteen of these for various storage reasons) and transferring data to learn their system. I’d know the transfer protocols, the encryption levels, the likely physical network structure, and JFS if at all possible–at a BARE minimum.

If you have an interview with Microsoft’s IE10 team, you’d better be in front of IE6, 7, 8, and 9, knowing what major updates occurred between browser versions, which HTML versions were implemented where, security holes and how to plug them, and what cross-browser issues remain to be addressed, and that’s not even the bare minimum.


public tip
{
//Use the code of the team with which you're interviewing before you walk in the door.
}


We had a great time; the young ladies who asked questions were thoughtful, imaginative, and genuinely interested in careers as programmers. We hope that we encouraged you, challenged you, and mentored you, as we ourselves were mentored by the ladies who inspired us.

Best of luck!

For those of you looking for more help with technical interviews, head to Tech Interview Help.

I must make a confession before I continue with this post – I adore Python. It’s made me a better coder. I think about problems differently than I used to, I’m better at breaking them down into tiny components that are easy to code. My coding in other languages improved drastically as a direct result of learning Python – and using it in a Pythonic manner.

I used to use Bash for scripting. That’s what Bash is for, right? I use a Bash shell, so it only made sense.

One day, I was processing some xml scripts. I had multiple xml files with the same root node, and needed to put them all together into one big xml file. Frustrated at some sticking point or other, I decided to see if I could do it with Python. Oh, my goodness, it was SO EASY.

Before long, I had a string of utility files to handle common tasks that I was always scripting.

Reusability

When scripting, we often have tasks that we do over and over, but with slight changes. Rather than having a base set of methods that you copy out of and then change for each new usage, you can create utility files of classes and methods to use. Add methods to classes to handle new tasks, or allow new variables to be passed in for different usages. With Python’s named variables, you can change a method without effecting or needing to change other code that calls it.

One of the base tenants of Python is DRY (don’t repeat yourself). If you find yourself writing the same code more than once, put it in a place where it can be reused, like a method in a class or a function in a utility file.

Building up a libarary of these types of files is a great way to expand your toolbox. The longer you do it, the easier tasks become, because you’ve already done the work.  Lots of scripting projects are, “Just like the one you did for x, but with this minor change”.

Testing

Python the community is heavily in favor of testing. One reason this is helpful for scripting is the case I mentioned above, when you change a method to handle some new functionality that you need. How do you make sure this new fuctionality doesn’t break old code? You test it. Doctesting and unit testing are built in to Python, no hunting around for which framework is best, balancing framework versions with script versions, or figuring out how to import your framework on a different operating system.

Doctesting

I love doctesting. In one fell swoop, you are showing how to use code, documenting that code, and proving that it works as expected.

Doctesting is very easy to do. Let’s say we create a method to square a number.

def square(numberIn):
    return numberIn * numberIn

No documentation there, let’s fix that.

def square(numberIn):
    """Returns the square of the number passed in"""
    return numberIn * numberIn

The doctest actually goes inside the documentation you’ve just created.

def square(numberIn):
    """Returns the square of the number passed in

    >>> square(2)
    4
    """
    return numberIn * numberIn

So, you use >>> to delineate code that is going to be tested. That’s the same >>> you see when you’re working at a Python prompt. In this case, we’re calling our method and passing in 2. On the next line, put the expected result, which is 4. You can put as many of these tests as you like in the documentation block, separate them with a blank line. You can even put error checking here.

def square(numberIn):
    """Returns the square of the number passed in

    >>> square(2)
    4

    >>> square('three')
    Traceback (most recent call last):
    ...
    TypeError: can't multiply sequence by non-int of type 'str'
    """
    return numberIn * numberIn

I got that traceback by using my function at a command prompt.  I copied and pasted it into my doctest.  I deleted the variable stuff between the two important lines and replaced it with ellipses.

In order to run the doctest, you have to add the following to the bottom
of your file:

if '__main__' == __name__:
    import doctest
    doctest.register_optionflag('ELLIPSIS')
    doctest.testmod()

Note that I’ve registered the ellipsis option flag. This allows you to use … as a wildcard so you can skip over some of the expected output. It keeps your code cleaner and lets you handle situations where expected output might be different – say – generating a random number.

Ok, now you can run the file. Let’s say we called it utility.py.

$ python utility.py
$

No output. That’s the default. In order to see the test results, you need to use the verbose flag.

$ python utility.py -v

Trying:

    square(2)
Expecting:
    4
ok
Trying:
    square('three')
Expecting:
    Traceback (most recent call last):
    ...
    TypeError: can't multiply sequence by non-int of type 'str'
ok
1 items had no tests:
    __main__
1 items passed all tests:
   2 tests in __main__.square
2 tests in 2 items.
2 passed and 0 failed.

Test passed

$

And there are our test results – everything passed.

Aside from the option to put doctests in your code, you can also create txt files for documentation and add doctests to them. This is what bigger projects tend to do, especially when they have multiple files of code to deal with.

Unit tests are another great way to test that is very helpful for scripting. Every time you get a new requirement, add in a unit test for any situation you can think of that would effect that new requirement. Test things going right, things going wrong, and any unexpected behavior or input you can think of. If you find an error that isn’t covered in your tests, create a unit test to cover it. A baseline of code like this ensures that any future changes won’t break existing code. If it does, it will make the error really easy to track down – you won’t have to try to remember all the past requirements.

Easy for the next person to maintain

Between keeping code in one place, not repeating yourself, and having robust testing, you’ve just made maintaining this code really, really easy for the next person that comes along. Even if they don’t know Python, a glance at your robust documentation and clear code will make it easy to make small changes. Running the tests will leave them confident that their changes won’t have a negative effect on other code.

We all want to be able to go on vacation and not get a call that someone broke your code. Clear code with lots of tests are the best way to ensure a relaxing break.  Python makes this quick and easy, so you can move on to something hard.