Be the change

Since this is our first post on our blog in Spanish (this article is a translation of Ser el Cambio), we wanted to start off with a bang by featuring one of our most challenging projects we’re facing as a company. Though our offices might not be new, our engineering team is constantly growing, and one of our primary resolutions this year is that our team continue to grow from life experiences, different cultures, and, above all, achieve a balance in terms of gender representation.

Our goal is clear… More women in engineering! However, when we sat down to try and figure out how we would achieve this goal, we found that it was a whole lot more than just looking for women to submit their resumes. We discovered that the industry offers little-to-no support for women, leaving them little room to grow and practically no voice when it comes time to make important decisions.

Faced with all of this, we realized that we didn’t want to be a business that just simply tried to put more women to work. In order to tackle this issue more head-on, we developed a working group that we chose to call #ada-lovelace in honor of the great scientist and role model who served as the face for the representation of women in computer science. The idea of this group is to dream up and create a working environment in which all women feel safe, represented, and fully integrated into our business.

The group is made up of men and women who understand that women’s presence and opinions are necessary and important within our company and, above all, within every level of the field of engineering. During most of 2017 and the first part of 2018, this group has taken on the following tasks:

  • Create a space where current and future mothers within our company can feed their babies in total privacy without the fear of being observed.
  • Promote and sponsor groups dedicated to educating women in science and technology, such as Django Girls and Agile Woman.
  • Create confidential working groups within the company where concerns over day-to-day work and workplace issues can be shared in a respectful environment.
  • Ensure that interview panels have women on them for positions of all levels and roles. The idea behind this is that the hiring process shouldn’t be segregated by gender, rather, than all interviews should be focused on job-relevant abilities.
  • Creation of the first “seedlings of engineers” within our company, which will be a school for up and coming professionals that may or may not already have professional experience. Within this group, we will strive for a certain percentage representation of women in order to promote their entry into the workforce.

As part of this projects, we held interviews with women that are part of our engineering team in order to find out what had made them consider Eventbrite as a possible workplace (Interview in Spanish):

We are fully aware that this is an on-going effort, and we must continue to make progress in order to solve this problem, which not only affects us as a company, but the industry, and society as a whole.. It’s a challenge in and of itself to identify the problems that cause the gender gap to form within the realm of education and training, which then extend to the workplace and the positions that women one day might find themselves in.

You might ask yourselves, Can they pull this off? We’re on the way. Like all big changes, we need time to generate results and see the overarching benefits of this work; however, we’ve begun with the first step in the right direction.

“Never doubt that a small group of thoughtful, committed citizens can change the world; indeed, it’s the only thing that ever has.”

– Margaret Mead

Wrote in Spanish by Natalia Cortese

Translated into English and published by Melisa Piccinetti

Reviewed translation by Sebastian Torres

Doctor Python: Or How I Learned to Stop Worrying and Love ES6

Have you learned ES6 yet? Oof. When people started asking me that, I’d feel a sense of pressure that I was missing out on something. What was this “ECMA” people kept talking about? I was worried.

But Python helped me learn ES6. Weird, right? Turns out a lot of ES6 syntax overlaps with that of Python, which I learned at Eventbrite. Much of the syntax is shared between the two languages, so they kind of go hand in hand. Kinda.

Without further ado, let’s talk about these two buddies.


Block Scope

When I first started learning JavaScript (back in “ancient” ES5 days), I assumed several things created scope. I thought that conditionals created scope and was quickly told that I was wrong.

“NO. Only functions create scope in JavaScript!”

So when I found out that with ES6, we now have block scope, I was like, “WAT”.

A massive inflatable rubber ducky floating in front of a pier and building.

With the addition of const and let to ES6, block scope! Wow! I felt like I’d predicted the future.

function simpleExample(value) {
  if (value) {
    var varValue = value;
    let letValue = value;
    console.log(varValue, letValue); // value value

  // varValue is available even though it was defined
  // in if-block because it was "hoisted" to function scope
  console.log(varValue); // value

  // letValue is a ReferenceError because 
  // it was defined within the if-block
  console.log(letValue); // Uncaught ReferenceError: letValue is not defined

What else creates scope in JavaScript, ES6, and Python? And what kind of scope do they use? Check out the following table:

JavaScript Python
Scope Lexical Lexical
Namespace Functions, Classes [ES6!], Modules [ES6!], Blocks [ES6!] Functions, Classes, Modules
New Identifiers Variables, Functions Variables, Functions, Classes

Template Literals

I like to think of template literals as Mad Libs. Did you have them as a child? Sentences were missing words, and you could write anything you wanted into those spaces. You only had to conform to the specified word type: noun, pronoun, verb, adjective, exclamation.

Mad Libs that read "mothers sit around burmping. Last summer, my little brother fell in a/an hairdo and got poison palmtree all over his butt. My family is going to Winsconsin, and I will.."

Similarly, template literals are string literals that allow embedded expressions. They were originally called “template strings” in prior editions of the ES2015 specification.

Yup, these already exist in Python. I had actually learned about literal string interpolation in Python, which made it that much easier for me to understand in ES6. They are great because you no longer need the ridiculous concatenation found in older versions of JavaScript.

let exclamation = 'Whoa!';
let sentence = `They are really similar to Python.`;

console.log(`Template Literals: ${exclamation} ${sentence}`);
// Template Literals: Whoa! They are really similar to Python.
print '.format(): {} {}'.format('Yup.', 'Quite!')
# .format(): Yup. Quite!


Default Parameters

Yup. Python’s got ‘em too. Default parameters set a default for function parameters. This is most effective for avoiding bugs that pop up with missing arguments.

function nom(food="ice cream") {
  console.log(`Time to eat ${food}`);

nom(); // Time to eat ice cream
def nom(food="ice cream"):
  print 'Time to eat {}'.format(food)

nom() # Time to eat ice cream

Rest Parameters & *args

Rest parameter syntax allows us to represent an indefinite number of arguments as an array. In Python, they’re called *args, which again, I’d already learned! Are you sensing a pattern here?

Check out how each of the languages bundles parameters up in neat little packages:

function joke(question, ...phrases) {
  for (let i = 0; i > phrases.length; i++) {

let es6Joke = "Why does JS single out one parameter?"
joke(es6Joke, "Because it doesn't", 'really like', 'all the REST of them!');

// Why does JS single out one parameter?
// Because it doesn't
// really like
// all the REST of them!
def pirate_joke(question, *args):
  print question
  for arg in args:
    print arg

python_joke = "What's a Pyrate's favorite parameter?"

pirate_joke(python_joke, "*args!", "*arrgs!", "*arrrgs!")

# What's a Pyrate's favorite parameter?
# *args!
# *arrgs!
# *arrrgs!



Oh boy, we’re gonna talk about prototypal inheritance now! ES6 classes are actually syntactic sugar and based on the prototype chain found in ES5 and previous iterations of JavaScript. So, what we can do with ES6 classes is not much different from what we do with ES5 prototypes.

Python has classes built in, allowing for quick and easy Object Oriented Programming (Python is down with OOP.). I always found the prototype chain extremely confusing in JavaScript, but looking at Python and ES6 classes side by side really hit home for me.

Let’s take a look at these ES6 “classes” based on the prototype chain:

class Mammal {
  constructor() {
    this.neocortex = true;

class Cat extends Mammal {
  constructor(name, years) {
    super(); = name;
    this.years = years;

  eat(food) {
    console.log('nom ' + food);

let fryCat = new Cat('Fry', 7);'steak');
class Mammal(object):
  neo_cortex = True

class Cat(Mammal):
  def __init__(self, name, years): = name
    self.years = years

  def eat(food):
    print 'nom %s' % (food)

fry_cat = Cat('Fry', 7)'steak')

A big difference between ES6 Classes and ES5 Prototypes: you can inherit more easily with classes than with the prototype chain. This is very similar to Python’s structure. Neato!

So there you have it. Five quick examples of Doctor Python helping me stop worrying and love ES6. It’s been many months now, and my ES6 usage is now pretty explosive.

Screen capture of Major Kong riding on top of a bomb falling from a plane in the film, Doctor Stangelove.

Mother May I?

Important announcement about updates to API V3 and evolving permissions at Eventbrite

If you want to skip straight to the content on the changes that will impact our API developers please visit our Google Group and read the message pinned to the top.

Permissions have been an ever-growing challenge at Eventbrite as we have grown over the years. With scale, permission management has become difficult because of the storage requirements, speed, and latency. Imagine a feature where you need to check the permissions for ten users of an account and 100 of the account’s events. Now take into consideration that each individual event can have multiple permissions associated with it. You can start to get an idea of both the storage requirements and the speed considerations. Even if each permissions check is very fast, executing all of them serially will become slow.

In late 2016 we began working on a Python Library that will change the way we grant users permission to the various entities that exist within Eventbrite. Essentially this library aims to answer the following questions:

    • Can User X take action Y on entity Z

Entity can be event, order, etc.

    • What Users can take action Y on entity Z
    • What entities can User X take action Y on

When the library is invoked it is given parameters which indicate the entities/users are relevant *before* checking permissions. If there are 10 events and 5 users you care about, you load permissions for all these events/users doing a one-time SOA call. Once you have loaded permissions this way, checking permissions is very fast because it’s all in memory. Permissions are inferred in a couple of ways. Inference means that not every single permission is stored in the database.

More general permissions imply more specific ones.

If a User has full permissions on “event” that infers that that user has permissions to do more specific things to that event (change details, add tickets, etc.)  These permissions are not stored, but are inferred.

Permissions on a higher object infer permissions on a lower one:

If a User has full permissions on a “user” that infers that that user has permissions on all the events that are owned by that user.

This allows you to do something like “grant event detail editing” to User Y on User Z. The effect is that User Y can edit the event details for any event owned by user Z.

These can be used powerfully in combination. If you say “grant the event privilege to User Y on User Z” it means that User Y can now do anything to any event owned by User Z.

Inference greatly simplifies operations such as changing the role of a user or bulk deleting events. If we were to store each permission separately, we could potentially need to update thousands of rows in the database to accomplish this one task.

Most recently the permissions library was used as one part of an update we are making to our product offering. Starting this fall, this update will allow organizers to choose between three tailored product packages to best achieve their goals. You can learn more about the new Eventbrite packages here.The rollout will affect our API developers. If you are an API developer please visit our Google Group for detailed information on how your apps will be impacted and how you can prepare.

Photo by Christian Wiediger on Unsplash

Britecharts v2.0 Released

Britecharts, Eventbrite’s D3 based charting library, has grown with additional charts contributed by the community. It is now a mature library, but it still lacks some charts used in today’s standard DataViz suites. We want to add these charts, and that means we will experience some growing pains. We wondered, how we could make that process easier? Continue reading

Packaging and Releasing Private Python Code (Pt.1)

When dealing with a large Python code base managed by multiple teams, you often find that you need to be able to package and release this code independently. Most best-practices guides for releasing Python packages focus on public packages, and do not cover complex dependencies. In this post I’ll focus on how we, at Eventbrite, release our internal Python packages and avoid dependency hell while doing so. This first part will cover defining packages and their dependencies, while the second part will cover building and distributing Python wheels internally.

Continue reading

Introducing Britecharts: Eventbrite’s Reusable Charting Library Based on D3

The usual workflow when developing interactive data visualizations with D3.js is based on the significant number of examples that the D3 community provides. They are broad and useful, but they are still not ideal. Most of the time, they require a lot of effort to integrate into your code and to make them production-ready.

In a previous series of posts about Leveling Up D3, I talked about a different way of building D3.js charts, using the Reusable API, building our components via TDD and improving them with events and refactorings. Following those ideas, and with the help of Eventbrite’s design team, we have been working on our chart library, and now we want to share it with you. It’s called Britecharts.

Continue reading

5 Good Practices I Follow When I Code Using Git

Nowadays using Git is almost a rule and of course tools like GitHub, GitLab and Bitbucket are almost a standard.

To me, it really doesn’t matter the size of the project that I am coding, it could be for my current job, a freelance one or my personal apps: I always use Git.

I think that habit is like a cane to walk the road to perfection. That’s why I do not just use Git but also always follow some best practices that I have learned.


  1. Use branches for features, AB tests, fixes, etc.
  2. Commit often.
  3. Use clear commit messages.
  4. Always use pull requests.
  5. Keep master releasable.

6 Unsuspecting Problems in HTML, CSS, and JavaScript – Part 2

Welcome to part 2 of our series covering six unsuspecting problems and scenarios that one may come across in HTML, CSS, and JavaScript. In part 1 we talked about the Block Formatting Context and Margin Collapsing. In this post, we will be covering DOM reflow and event delegation, and how they affect the performance of your application.

DOM Reflow

DOM reflow is the drawing or redrawing the layout of all or part of the DOM. This is an expensive process, but unfortunately easily triggered. This could cause a noticeable performance degradation of a web app that requires a lot of user interactivity i.e. drag & drop and WYSIWYG editors. If you are developing a highly interactive web app, then you will most likely at some point trigger a DOM reflow.

Eventbrite’s switch to ReactJS is one answer to the poor performing native DOM. ReactJS creates its own virtual DOM, which optimizes which parts of the web page needs to be re-rendered.

Continue reading

6 Unsuspecting Problems in HTML, CSS, and JavaScript – Part 1

HTML, CSS, and JavaScript are known for having various quirks and unsuspecting behavior causing developers to jump through hoops, climb mountains, and perform Houdini-esque magic tricks to fix them. I made a list of six solutions to common head-scratchers that I’ve run across while dabbling in the DOM, so you won’t have to.

This is the first of a three part series. We will begin by tackling two fundamental concepts that exist in HTML and CSS, which may help you reason out solutions to tricky scenarios that exist in the Wild Wild West that is front-end development.

Block Formatting Context

Block formatting context is a fundamental component to how elements in web pages are rendered. It describes how they stack and interact with each other resulting in the final visual output of the webpage.

Continue reading