Danielle Leong

Setting goals with your direct reports

Thu, 22 Mar 2018 00:00:00 +0000

Now that I’ve transitioned to management, I’ve found myself becoming a person I never thought I would be. I like fitted blazers. I wear trousers instead of skinny jeans (sometimes). I go to the gym. I like goals. Ugh. Who even am I?

I’m a firm believer in setting good professional goals. They have to be measurable (duh), but most importantly, they have to be a living document that you maintain with your direct report.

Once you set up good goals, it becomes extremely easy to track a person’s growth, surface issues before they become a big problem, and make performance reviews easier. However, most people hate doing them. This is my current process for making and updating goals.

Setting initial goals

Treat goal-setting as a pairing exercise. I ask my direct reports to open a markdown file in their GitHub repository (or Google doc) for one quarter. This is to gauge what kind of things the person initially is interested in, without my input.

We set up time at the beginning of the quarter (or end of the quarter) to walk through these goals. I bring up the engineering levels of the person and we go through them to see what kinds of things they excel in and what areas could use some work.

Then we work together to create measurable, time-limited goals (with checkboxes!) for the quarter based on their original goals and the engineering goals. (i.e. “Fix 6 bugs off the bug board this quarter to help with technical debt”) When putting together estimates, I make it clear that these can always change based on changing circumstances.

Monthly follow ups

The most important part of this process is the monthly follow up. I set a reminder on my calendar (I use OmniFocus) to review goals once a month to make sure they are still relevant. For example, if a person stated “Fix 6 bugs off the bug board this quarter to help with technical debt” but has spent most of the first month working on a very complex feature, then we might reduce the goal to “Fix 4 bugs off the bug board this quarter to help with technical debt and ship 1 major feature”.

It’s also a good way to surface problem areas. If a person commits to fixing 6 bugs in a quarter, but they haven’t gotten any started, what is the cause of that problem? Was the onboarding not thorough enough? Are they having problems with their local development machine? Are the bugs too hard than their current level? Interpersonal issues?

I also use this time to add any additional projects the person has been working on (i.e. committees, Employee Resource Groups, any kind of invisible or emotional labor) to make sure that it’s documented, or any interpersonal concerns I’ve noticed over the last few weeks. It’s ok to write them pre-checked. The most important thing is documenting changes as they happen!

Annual reviews rollups

With all of these past notes, it makes writing reviews much easier, makes it clear if too much time is spent in any one particular area, and helps guide the person to work on areas they may not naturally want to work on.

It also makes it much easier to spot if they’re available for a promotion, since it clearly shows where they are in the engineering levels.

I hope this helps you out!

Image source: https://flic.kr/p/8jvw78

How to add smooth scrolling to SVG anchor links

Wed, 03 Jun 2015 00:00:00 +0000

If you’ve done any frontend work, you know that SVGs are ~~the new hotness~~ what you should be using for just about everything. They’re vector images that are easily scalable and relatively small in file size, making them a no brainer to use with retina screens and mobile devices.

I was working on a problem this week and ran into a roadblock. The goal was to make this diagram:

And link each one of the rings to an anchor link further down the page and add some animation to create a smooth scrolling effect.

But it turns out that making concentric svg rings that link to anchor points and have an animation is much more irritating than one would think.

Layering svgs on top of one another presents problems when you try to link them, because the clickable areas overlap, with the largest ring overlapping all of the others. After a while, I saved each one of the rings as an svg using Illustrator and pasted the code making the rings directly into the page (you only need the path). Then I wrapped each path with an anchor link using xlink:href (svgs are special snowflakes like that).

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
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 228 228" enable-background="new 0 0 228 228">
	<g transform="scale(.6) translate(165, 155)">
		<path stroke="#fff" stroke-miterlimit="10" d="M49 37.3s11.6-1.5 11.6-12.8c0-7.2-5.9-13.1-13.3-12.8-3-6.1-9.1-10.3-16.3-10.3-9.6 0-17.4 7.5-17.9 16.9-6-1.3-11.6 3.3-11.6 9.4 0 8 6.9 9.4 9.4 9.6" fill="none"/>
		<g fill="#fff">
			<path d="M30.8 18.2c-6.3 0-11.4 5.1-11.4 11.4S24.5 41 30.8 41c6.3 0 11.4-5.1 11.4-11.4s-5.1-11.4-11.4-11.4zm0 19.9c-4.7 0-8.4-3.8-8.4-8.4 0-4.7 3.8-8.4 8.4-8.4 4.7 0 8.4 3.8 8.4 8.4 0 4.6-3.8 8.4-8.4 8.4z"/>
			<circle cx="33.6" cy="26.8" r="2.4"/>
			<circle cx="33.6" cy="32.5" r="2.4"/>
			<circle cx="27.9" cy="32.5" r="2.4"/>
			<circle cx="27.9" cy="26.8" r="2.4"/>
		</g>
	</g>
	<g transform="scale(.4) translate(180,120)">
		<a xlink:href="#link1">
			<path fill="#ff9" d="M114 1C51.7 1 1 51.7 1 114s50.7 113 113 113 113-50.7 113-113S176.3 1 114 1zm0 176c-34.7 0-63-28.3-63-63s28.3-63 63-63 63 28.3 63 63-28.3 63-63 63z"/>
		</a>
	</g>
	<g transform="scale(.4) translate(130,70)">
		<a xlink:href="#link2">
			<path fill="#AA9463" d="M164 1C74.1 1 1 74.1 1 164s73.1 163 163 163 163-73.1 163-163S253.9 1 164 1zm0 276c-62.3 0-113-50.7-113-113S101.7 51 164 51s113 50.7 113 113-50.7 113-113 113z"/>
		</a>
	</g>
	<g transform="scale(.4) translate(80, 20)">
		<a xlink:href="#link3">
			<path fill="#564E5D" d="M214 1C96.6 1 1 96.6 1 214s95.6 213 213 213 213-95.6 213-213S331.4 1 214 1zm0 376c-89.9 0-163-73.1-163-163S124.1 51 214 51s163 73.1 163 163-73.1 163-163 163z"/>
		</a>
	</g>
	<g>
		<a xlink:href="#link4">
			<path fill="#4E6C80" d="M263,0C117.7,0,0,117.7,0,263s117.7,263,263,263s263-117.7,263-263S408.3,0,263,0z M263,476 c-117.4,0-213-95.6-213-213c0-117.4,95.6-213,213-213s213,95.6,213,213C476,380.4,380.4,476,263,476z"/>
		</a>
	</g>
</svg>

Then I tried to use the following Javascript to add smooth scrolling to the anchor links:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
$(document).ready(function() {
	$('a[href^="#"]').on('click',function (e) {
		e.preventDefault();
	
		var target = this.hash;
		var $target = $(target);
	
		$('html, body').stop().animate({
			'scrollTop': $target.offset().top
		}, 900, 'swing', function () {
			window.location.hash = target;
		});
	});
});

This didn’t work because of our delightful xlink:href ! So I changed it to:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
$(document).ready(function() {
	$('a[*|href^="#"]').on('click',function (e) {
		e.preventDefault();
	
		var target = $(this).attr('xlink:href');
		var $target = $(target);
	
		$('html, body').stop().animate({
			'scrollTop': $target.offset().top
		}, 900, 'swing', function () {
			window.location.hash = target;
		});
	});
});

Breaking it down, we want to select all the different types of hrefs on the page. By using the jQuery selector *, we say we want to select all the different types of href, regardless of if they’re xlink:href or regular links. .hash() doesn’t work with xlink:href so we use $(this).attr('xlink:href') to grab the anchor link. Then we scroll to the anchor link’s position based on the coordinates of the element we’re linking to.

Hope this helps! Happy anchor linking!

2014 in review

Mon, 29 Dec 2014 00:00:00 +0000

2014 was an interesting year full of some hard life lessons, emotional turmoil, and a lot of growth. Here’s some life lessons I learned this year.

###Fighting your demons is hard### August 2013, I was sexually assaulted by a massage therapist. Instead of burying the pain, I decided that this time I would work through it. And you know what? Dealing with trauma sucks. It is way easier to stick your head in the sand and tell everybody and yourself that you’re okay. It means random panic attacks, intense bouts of crying, and worst of all: being honest with yourself that you will never be the same. It sucks because you don’t know what’s wrong and why it’s happening or when you’ll get better. But it gets better. Then it gets worse. But ultimately, it gets better.

###Asking for help is even harder### Admitting that something is wrong is really difficult. Asking for help and allowing people to help is even harder. This year I was very open and honest about what happened to me and the results surprised me: people were really supportive. It’s easy to think that you’re all alone when you’re going through rough times, but it turns out that the people who care about you still care about you even when you’re struggling. And opening up about “taboo” subjects like sexual assault makes it easier for others to feel less alone. I can’t tell you how many people reached out to me to tell me their story about assault. Even more people reached out to offer their support. I realized I have some really good friends who are there and who care. And that’s a great feeling to have.

###Doing what’s right for you, even if it’s scary### I bought a motorcycle. I love my motorcycle. I had always wanted a motorcycle but was scared of crashing and dying. But in January 2014, I decided what the hell? I’m going to do what I always wanted to do and buy my motorcycle because I can! Motorcycles are terrifying and I crashed, but I got right back on and haven’t looked back. It still is the best purchase I’ve ever made.

###There’s something out there more important than you###

@tsunamino helping middle school girls get interested in #twilio by taking selfies! pic.twitter.com/3niRsZ0ClG
— Dom DeGuzman (@Itshella_dom) May 28, 2014

This year I decided to do more than talk about giving back and co-founded Skittles, Twilio’s diversity initiative. Our focus was to increase diversity and inclusion in tech, and I’m happy to say it’s found a good home at Twilio. There’s a lot of problems out there, but there’s also a lot of really great people out there who want to help. It helps me get out of bed in the morning knowing that I work with people who are truly passionate about making a difference and helping to change the face of technology.

###Public speaking is pretty great###

This was the year of getting out there! I spoke at some pretty big conferences like Google I/O and IgniteSF. I was even on TV! Check out a full list of my public appearances here.

###Traveling is a must### I went to Europe for the first time this year, and it was an amazing experience. I had always wanted to go to Paris and finally got to go to the land of cheese, croissants, and art. I went to museums and cried from happiness. It was a truly life-changing experience and I cannot wait to travel more.

What's an object? A beginner's guide to Object Oriented Programming

Mon, 22 Dec 2014 00:00:00 +0000

tl;dr

Object Oriented Programming (OOP) is an incredibly important concept that is difficult to explain to a person new to programming. This post will attempt to break down the concept of OOP into plain English using baking as an example.

Objects. How do they work?

When I started programming, the term Object Oriented Programming (OOP) was being thrown around constantly, but the internet doesn’t always take into consideration that newbies don’t know how to read technical documentation. Technical documentation, even that which is aimed at new programmers, often forgets to take into consideration the basics that one is “supposed to know”. One of these things, I found, was as simple as explaining what an object is.

For the longest time, I thought arrays and objects were the same thing. An array is an ordered map. An easy way to think about this is like a grocery list.

    (
        [0] => sugar
        [1] => flour
        [2] => butter
    )

If you wanted to reference a specific item in that array, you could just print $array[0] and get “sugar”.

Objects are slightly more difficult to explain. Even when you search on Google, it tells you that there’s no way you can sum it up easily:

The Oracle article actually does a decent job at explaining it, but I’ll give an example that finally made everything click for me.

For this lesson, we will cover the following terms:

Class
Constructor
Object
Instance
Inheritance
Function (or Method in other languages like C++ or Java)

And because I like baking, I’ll use the class Recipe.

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
<? php
class Recipe {
	protected $ingredients;
	protected $steps;

	public function Recipe() { 
		$this->ingredients = array();
		$this->steps = array();
	}

	public function addIngredient($ingredient) {
		$this->ingredients[] = $ingredient; 
	}

	public function addStep($step) {
		$this->steps[] = $step; 
	}

	public function printOutput() {
		echo "Ingredients:\n";

		for($i = 0; $i < count($this->ingredients); $i++) {
			echo $i . " " . $this->ingredients[$i] . "\n";
		}

		// Prints numbered steps
		echo "Steps:\n";

		for($i = 0; $i < count($this->steps); $i++) {
			echo $i . " " . $this->steps[$i] . "\n";
		}

		echo "\n";
	}
}

Class

In this example, Recipe is an example of a Class. A Class is your source of truth or set of basic instructions for the thing you’re trying to make. It should be pretty vague and generic so that you can reuse it in other situations. At its most basic core concept, a recipe is a list of ingredients and a list of steps you follow with those ingredients.

Constructor

Your Constructor (line 6) contains instructions on how you want to build (or instantiate) your Class. In this case, you build your recipe by having a list of ingredients and a list of steps.

Object

Now we want to actually do something with our recipe.

//Create a new instance of Recipe called $sugarCookie
$sugarCookie = new Recipe();
$sugarCookie->addIngredient("sugar");
$sugarCookie->addIngredient("flour");
$sugarCookie->addIngredient("butter");
$sugarCookie->addStep("Mix together");
$sugarCookie->addStep("Cut out shapes");
$sugarCookie->addStep("Put in oven");
$sugarCookie->printOutput();

We want to make an actual item (Object) by cloning our original recipe (Class). Here, we create a new instance of Recipe and call it $sugarCookie. We add our ingredients, run our cookie magic, and get magic tasty goodies out of it.

Instance

An Instance is an Object that is a copy of a Class. $sugarCookie is an instance of Recipe. We can make as many Instances of Recipe as we want!

//Create a new instance of Recipe called $pie
$pie = new Recipe();
$pie->addIngredient("pie crust");
$pie->addIngredient("filling");
$pie->addStep("Roll out crust");
$pie->addStep("Fill with filling");
$pie->addStep("Roll out top crust");
$pie->addStep("Put in oven");
$pie->printOutput();

Here we have $pie as another Instance of our original class of Recipe. We have completely different variables (pie crust and filling) but the same basic structure is the same as $sugarCookie.

Inheritance

Remember how I said a Class should be as vague as possible? The reason is because of Inheritance.

class Brownie extends Recipe {
	public function Brownie() {
		parent::Recipe();
		$this->ingredients[] = "chocolate";
	}
}

$brownie = new Brownie();
$brownie->addIngredient("sugar");
$brownie->addIngredient("flour");
$brownie->addIngredient("eggs");
$brownie->addStep("Mix together");
$brownie->addStep("Bake");
$brownie->printOutput();

Here we are extending our Recipe to create a new class of Brownie. Since all brownies have a lot of chocolate, it makes sense that our Brownie class should add it by default. So while our Brownie class inherits all of the basic ingredients and steps from our Recipe class, it doesn’t do enough to cover this specific class’s needs, so we modify it as needed.

Function

Looking through our Recipe we see things like public function addIngredients(). This is an example of a Function. I like to think of functions as verbs. They do things to the variables (in this case, ingredients). Our functions should always be small and reusable to avoid surprises. In this case, addIngredients makes a list of the ingredients we need and nothing else.

Let’s look at it all together

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
<?php
//Make a new recipe class that is easy to duplicate 
class Recipe {
	protected $ingredients;
	protected $steps;

	public function Recipe() { //the constructor that builds our class
		$this->ingredients = array();
		$this->steps = array();
	}

	public function addIngredient($ingredient) {
		$this->ingredients[] = $ingredient; //adds ingredients to an array
	}

	public function addStep($step) {
		$this->steps[] = $step; //adds steps to an array
	}

	public function printOutput() {
		// Prints ingredients
		echo "Ingredients:\n";

		for($i = 0; $i < count($this->ingredients); $i++) {
			echo $i . " " . $this->ingredients[$i] . "\n";
		}

		// Prints numbered steps
		echo "Steps:\n";

		for($i = 0; $i < count($this->steps); $i++) {
			echo $i . " " . $this->steps[$i] . "\n";
		}

		echo "\n";
	}
}

//Create a new instance of Recipe called $sugarCookie
$sugarCookie = new Recipe();
$sugarCookie->addIngredient("sugar");
$sugarCookie->addIngredient("flour");
$sugarCookie->addIngredient("butter");
$sugarCookie->addStep("Mix together");
$sugarCookie->addStep("Cut out shapes");
$sugarCookie->addStep("Put in oven");
$sugarCookie->printOutput();

//Create a new instance of Recipe called $pie
$pie = new Recipe();
$pie->addIngredient("pie crust");
$pie->addIngredient("filling");
$pie->addStep("Roll out crust");
$pie->addStep("Fill with filling");
$pie->addStep("Roll out top crust");
$pie->addStep("Put in oven");
$pie->printOutput();


//Extend Recipe to create a new class of Brownie. Brownie inherits from Recipe
class Brownie extends Recipe {
	public function Brownie() {
		parent::Recipe(); //inherits the parent class's constructor
		$this->ingredients[] = "chocolate";
	}
}

//Create a new instance of Brownie called $brownie
$brownie = new Brownie();
$brownie->addIngredient("sugar");
$brownie->addIngredient("flour");
$brownie->addIngredient("eggs");
$brownie->addStep("Mix together");
$brownie->addStep("Bake");
$brownie->printOutput();

Scope

“But wait!” you exclaim. “If we’re using the same constructor in Recipe and Brownie (lines 7 and 42), how come we don’t end up with chocolate in our $pie? This is where something called scope comes into play. Scope is best described as the things (such as variables or functions) available to you at a given point. Looking at the graph below, variables and functions are available for inheritance (think of your parents giving you their DNA) but you’re unable to inherit “up” (you cannot affect your parents’ DNA).

Everything in our Class (all Variables and Functions) are available for use in all Objects that inherit (or extend) that class. Things within specific Objects are only available to the Object and the Functions within it. Variables used in a Function are only available to that Function. It’s like an apartment: a landlord can have the master keys and be able to get into the common area and your apartment, but your apartment key doesn’t work on anyone else’s apartment.

Conclusion

Object Oriented Programming is an incredibly important thing to learn, but it’s not always easy to understand all the different parts. People use all sorts of examples to try to explain it, but it didn’t really click with me until someone sat down and explained it to me in plain English using an example that I was intimately familiar with. This is just one way that I’ve found helped me learn. Hopefully it was helpful for you!

And here’s my favorite cookie recipe.

Photo credit

Moving from front end to full stack

Sun, 07 Dec 2014 14:39:12 +0000

##tl;dr##

I’m a front end web developer trying to move to full stack. Follow along with my journey here.

###Part 1: I want to be a wizard### When you’re a kid, you’re told that college will have all the answers for you. That if you pick the right major, then you’re set for life. You take SATs and ACTs and AP courses that all quantify how smart you are in relation to the other students in your class. You pick a college and you pick a major, thinking, “This is what I will do for the rest of my life!”

No one ever tells you that this is rarely what happens.

I was fortunate enough to go to a UC school and graduate with a BA in Sociology and a minor in Business Management. I thought I wanted to do Marketing. I liked people. I liked how they thought. And I liked writing. I got my first job as a copywriter for a small tech firm in Orange County, CA.

Then I realized just how much I disliked copywriting, people, and Marketing. Something wasn’t fitting. Something was unfulfilled.

Through a series of events, I found myself unemployed and decided I would use this time to study to become an engineer. I wanted to make things. The terminal was, and still is, one of the most magical things I have ever seen. You type a few mystery words and all of a sudden, magical lines of text appear and bam! Your computer has done something that couldn’t be captured in a shiny, rounded button interface. It was pure magic. I wanted to be a wizard.

Two months later, I learned enough about web development to land a job at Twilio as the company’s first front end web developer. I had done some web design at some former jobs and in high school, and managed to scrape by the technical interview. I had a long ways to go, though, and free online resources only teach you so much. I had never used git or made pull requests or even worked on a dynamic website. Looking at the code I wrote in those early days will make angels cry.

###Part 2: Chamber of Secrets### Nearly three years later, I find myself in an interesting spot. I’m restless with front end and want to learn more. Having never gotten a formal CS education, I find myself hitting a ceiling of knowledge. I’m familiar with concepts but I don’t how to describe them in terminology that “normal” developers use. You can’t exactly Google “my local env is broken and I don’t know why”. I’ve been strictly front end for the last few years, and I don’t know how the entire stack works.

And worse: I don’t know what I don’t know.

This blog is going to be how I hold myself accountable. As someone who is intimately familiar with Impostor Syndrome, I hope that this blog will be useful for others who are trying to learn full stack, as well as to prove to myself that I’m not a moron on the days when it seems that is the only conclusion.

###Conclusion### I will be exploring concepts that seem “normal” to most engineers but are completely obscure to someone without a CS degree. For those of you who are also trying to learn web development, I hope that we’ll be able to support one another in this difficult, annoying, infuriating, yet somehow incredibly rewarding journey.

And yes, I’m still waiting for my Hogwarts letter.