The Realistic Code Reviewer, Part I

So you’re on board with presenting code for others to review—but what the flipside of this?

Code review isn’t always easy to get right. Like any form of communication, it’s often fraught with opportunities for miscommunication and confusion—but working through these challenges for an improved end-result is immensely valuable. We’re here to help.

'And when did you last see your father?', 1878 by William Frederick Yeames

Consider your ability to support the author before offering a critique.

Making regular, bite-sized code reviews a part of your normal development process is a crucial first-step toward making this part of your process. But it’s more than just the first round of feedback that matters. Supporting the developer you’re reviewing is just a critical as your initial technical review.

Continue reading

Escapándome de las Software Factory

Introduction

Cuando se nos presenta la posibilidad de decidir un lugar para nuestro desarrollo profesional, ya sea en un país distinto al nuestro, o en una empresa diferente, suelen aparecer muchas preguntas … ¿Nos podremos desarrollar profesionalmente?¿ Alguien nos dará una mano para mejorar nuestro nivel profesional? ¿Nos resultarán atractivos los proyectos que nos ofrecen? y quizás la más dificil de todas, ¿Cuánto estamos dispuestos a involucrarnos con estos nuevos proyectos?

Estas preguntas son los fantasmas que nos persiguen a los largo de nuestra carrera. Vamos a intentar responder aquí, a algunas de todas estas.

Una empresa, un mundo posible.

Después de 12 años relacionado con informática/programación, entiendo (quizás más tarde que temprano) que nosotros y la empresa es lo que finalmente importa. Esta relación está formada de personas claro, pero cada persona necesita y debe encajar en este complicado sistema. Un buen ejemplo sería cómo nuestros pares interactúan y la cultura que esto ofrece…¿Somos todos serios? ¿Hacemos bromas? ¿Se habla de los problemas? O solamente se es tan educado que se pasa a ser pasivo-agresivo o simplemente se entiende que cada uno está solo en el mundo y debe encontrar cómo volverse necesario.

Continue reading

Help!ful Things YOU Can Do for New Developers

Last year, I wrote an article titled The Catch-22 of Being “Too Junior”. It detailed high-level conditions that companies should assess when considering hiring “junior” developers. This article follows up that post.

During my first two years as a burgeoning developer, I maintained a list of things veteran engineers did that helped me evolve as a software engineer. Here’s that list in all its glory:

Explain jargon that new developers might not know or understand.

I actually wrote an entire conference talk on this topic. Software engineering and web development have their own vocabulary, which is not easily understood. Keeping this in mind helps people in all roles of a company, from product managers to support agents and salespeople. It’s also a great way to practice empathy.

Notice that someone in your conversation circle looks confused? Don’t keep droning on! Clarify. Not everyone knows what dependency injection is.

Continue reading

Learning ES6: Enhanced Object Literals

object_literal

Wow, we’re making some good progress covering ECMAScript 6 features in this Learning ES6 series series. We most recently covered template literals and arrow functions. Now we zero in on the enhancements to object literals, another piece of ES6 syntactic sugar.

TL;DR

ECMAScript 6 makes declaring object literals even more succinct by providing shorthand syntax for initializing properties from variables and defining function methods. It also enables the ability to have computed property keys in an object literal definition.

function getCar(make, model, value) {
	return {
		// with property value shorthand
		// syntax, you can omit the property
		// value if key matches variable
		// name
		make,  // same as make: make
		model, // same as model: model
		value, // same as value: value

		// computed values now work with
		// object literals
		['make' + make]: true,

		// Method definition shorthand syntax
		// omits `function` keyword & colon
		depreciate() {
			this.value -= 2500;
		}
	};
}

let car = getCar('Kia', 'Sorento', 40000);

// output: {
//     make: 'Kia',
//     model:'Sorento',
//     value: 40000,
//     depreciate: function()
// }
console.log(car);

car.depreciate();

// output: 37500
console.log(car.value);

The enhanced object literals code examples page has many more examples showing off each feature in more detail. There are also some ES6 katas for testing your ES6 enhanced object literal knowledge.

Continue on for more details!

Continue reading

Eventbrite and SEO: The Basics

Search Engine Optimization is important for all sites, but at Eventbrite it’s critical to our business. Many of our pages are created by our organizers, and our ability to surface the events to relevant people is one of the ways we make sure our customers are successful. My name is Beck Cronin-Dixon and I am one of the Software Engineers at Eventbrite focusing on making sure our organizers’ events rank highly in Google and their customers are able to find the events they are looking for.

Before starting at Eventbrite, I was (of course) aware of the term SEO but didn’t fully understand its meaning or role in a company, especially in terms of programming. Through thorough digging I realized it is essential for any website that wants to have its service or products  in front of customers to invest in the right SEO tactics. In this post, I wanted to cover the very basics of SEO that we incorporate into the Eventbrite site and has helped us grow organic traffic year to year. 

When Search Engine Optimization is mentioned I usually receive two kinds of reactions: the first is confusion, and the second is hesitancy. While most people know that SEO is the practice of improving a website’s ranking within search engines they, it’s not often clear on how it can and should be done. 

The days of ‘build it and they will come’ are now over. Websites have to not only think about the quality of their content for users, but also how it will be perceived by search engines. High quality content that attracts a lot of eyes will always win for both. Google heavily weighs in the favor of sites with high authority and relevancy. This is often hard for sites that rely heavily on user generated content. Here at Eventbrite, we are always trying to improve the rankings of our organizers’ events and other Eventbrite pages. We often have to be on the lookout for user generated content that could be deemed duplicate or low content by Google. Too many of these pages could result in a low authority score, or worse, a penalty that can affect the whole site.

Continue reading

Search Precision and Recall By Example

I work on Event Discovery and Recommendation at Eventbrite, a feature central to how our users interact with the site. A critical aspect  of returning the best results is understanding the tradeoffs between precision vs. recall. If we focus on _precise_ event recommendations, the results will be highly relevant, but we may overlook some events that a user would enjoy and find relevant. Alternatively, if we focus on recall, then we will return tons events that the user is interested in, but we’ll also flood them with less relevant events. Unfortunately, it is rare for recommendations to have both high-precision and high-recall.

In the following post, I explain the notions of precision and recall by example and discuss the unavoidable tradeoffs required to build the best search and recommendation systems possible.

The Overview

Precision and recall are two fundamental measures of search relevance. Given a particular query and the set of documents returned by the search engine (the result set), these measures are defined as follows:

  • Precision is the percentage of documents in the result set that are relevant.
  • Recall is the percentage of relevant documents that are returned in the result set.

Admittedly, these definitions are a little hard to follow at first. They may even sound like the same thing. In the discussion that follows, we provide a thorough example that will help you understand these definitions and their differences. You’ll also begin to see why it’s so important to keep these concepts in mind when designing any application of search.

Additionally, we demonstrate how precision and recall are often at odds with one another. Generally, the more you improve recall, the worse your precision becomes, and the more you improve precision, the worse your recall becomes. This implies a limit on the best you can achieve in search relevance. Fortunately, you can get around this limit. We explore the details in the discussion that follows.

Continue reading

Eventbrite’s Search-Based Approach to Recommendations

At Eventbrite, we’re building an Elasticsearch-powered, content- and behavior-based recommendation system to match users with events they are sure to enjoy. John Berryman, our Aerospace Engineer turned Senior Discovery Software Engineer, talked about our approach, successes, failures, and future work at the intersection of recommendation and search at Elastic{ON}16.

Search Based Recommendations

Watch the recording of his talk here. 

Learning ES6: Arrow Functions

right arrow sign

So far in the Learning ES6 series, we’ve looked at block scoping, default parameters, destructuring, rest & spread operators, for-of operator, and template literals. Today let’s continue the series to learn about arrow functions, a.k.a. “fat arrow” functions.

TL;DR

Arrow functions are more or less a shorthand form of anonymous function expressions that already exist in JavaScript. In ES6 this looks like:

let squares = [1, 2, 3].map(x => x * x);

Is equivalent to this in ES5:

var squares = [1, 2, 3].map(function (x) {
	return x * x;
});

As you can see a lot of the verbosity of old-style function expressions is removed and what’s left is the fat arrow (=>) joining the two main ingredients of the function: the arguments and function body.

You’ll find the greatest utility in arrow functions in places where functions take an anonymous callback function, like event handlers (such as onClick, $.ajax, etc.) and array processors (such as map, sort, etc.)

Interested in learning about arrow functions in more detail? Feel free to check out the arrow functions code examples page, which shows off the features in great detail. You can also try your hand at ES6 katas to see how much you’ve really learned.

Let’s keep going!

Continue reading

Leveling Up D3: Events and Refactorings

This is the third and final post in the Leveling Up D3 series. In the first post, we talked about the Reusable Chart API and its advantages. And in the second article, we test-drove a basic bar char. In this post, we will carry out some refactoring and optimizations made possible by our new, shiny, and high-quality code.

Personal Note

I love refactoring and evolving my code, as I greatly value being proud of the code I produce. In general terms, in the Software Development field, it is pretty common to introduce bugs when new features are added to a product. This obviously isn’t ideal, but people have gotten used to it.

However, when we talk about improving a piece of code that is already on production, organizations do not like adding bugs when pushing those changes. And that’s why the previous steps were so important. Without the tests generated in the last post, we wouldn’t have the necessary confidence to refactor our charts code once it had been shipped.

Continue reading

Learning ES6: Template literals & tagged templates

template literals

Template literals and tagged templates are our 6th topic in the Learning ES6 series. If you’re new to the series, we most recently covered for-of loops and destructuring.

Template literals, as well as tagged templates, are still primarily syntactic sugar, so you can totally do them in ES5. In fact, we have been doing them in ES5 up to this point. But the amount of code needed to mimic these ES6 features in ES5, especially tagged templates, can be pretty substantial.

TL;DR

ES6 template literals are a brand new type of string literal, delimited by backticks (`), that natively support string interpolation (token substitution) and multi-line strings. And because they use backticks as a delimiter, they can include single and double quotes without needing to escape them.

Continue reading