What Choosing and Applying Eyeshadow Can Teach Us About Coding

As a full-stack software developer and certified eyeshadow enthusiast, I‘ve noticed that my two passions have more in common than one might think. The process of selecting and applying eyeshadow shades shares many similarities with the skills and thinking patterns used in programming.

In this article, I‘ll explore the fascinating parallels between eyeshadow artistry and coding craftsmanship. Whether you‘re a seasoned software engineer or an eyeshadow aficionado, I think you‘ll find some valuable insights and practical techniques that you can apply to both disciplines.

The Eyeshadow Industry and the Tech Industry

Before we dive into the technical aspects, let‘s take a moment to appreciate the scale and impact of the eyeshadow industry. The global cosmetics market is expected to reach $463 billion by 2027, with eyeshadow being one of the most popular product categories.^1

The software industry is also massive and growing rapidly. There are over 26 million software developers worldwide, and that number is projected to reach 45 million by 2030.^2 The global software market is forecast to reach $824 billion by 2025.

Both industries are driven by creativity, innovation, and a desire to help people express themselves and solve problems. They also face similar challenges around inclusivity, accessibility, and environmental responsibility.

As a developer who also loves makeup, I believe that the tech industry could learn a lot from the way the beauty industry has embraced diversity and empowered people of all backgrounds to participate and succeed. We need more diverse perspectives in both fields to drive meaningful progress.

Objects, Classes, and Eyeshadow Palettes

Let‘s talk about object-oriented programming (OOP) and how it relates to eyeshadow. In OOP, we organize code into objects that encapsulate related data and functions. Objects are instances of classes, which are like blueprints that define the properties and behaviors of a type of object.

An eyeshadow palette is like a class definition. It specifies the properties (the individual eyeshadow shades) and the behaviors (how the shades can be combined and applied) that are common to all instances of that palette.

Here‘s what the class definition for an eyeshadow palette might look like in Python:

class EyeshadowPalette:
  def __init__(self, name, shades):
    self.name = name
    self.shades = shades

  def apply_look(self, base, crease, lid, outer_corner, inner_corner):
    # function to apply eyeshadow using specified shades

Each individual palette that you own is like an instance of the EyeshadowPalette class. It has its own specific shade selections, but it inherits the common behavior of the apply_look method.

For example, I could create instances of my favorite palettes like this:

naked_honey = EyeshadowPalette("Naked Honey", ["Flyby", "Sweet", "Swarm", "Amber", "Sting"])

norvina_pro_pigment_vol_2 = EyeshadowPalette("Norvina Pro Pigment Vol. 2", ["Eclectic", "Celestial", "Volatile", "Passion", "Drama"])

Each palette instance contains a name and list of shades specific to that palette, but they all have access to the apply_look method defined in the EyeshadowPalette class.

The power of OOP is that it allows us to create abstractions and model real-world entities in a way that‘s modular and reusable. Just like how you can reach for different eyeshadow palettes depending on the look you want to create, you can instantiate different objects based on the data and functionality needed for a particular task.

Recursion, Iteration, and Eyeshadow Blending

Another key concept in programming is recursion – when a function calls itself repeatedly until a certain condition is met. It‘s a powerful technique for solving complex problems by breaking them down into smaller subproblems.

Recursion is often compared to the concept of iteration, which is when you use a loop to repeat a process until a condition is met. Both can be used to achieve similar results, but they approach the problem differently.

I like to think of eyeshadow blending as a recursive process. When you‘re blending out the edges of your eyeshadow, you‘re essentially taking a small subproblem (a harsh line) and recursively breaking it down into smaller and smaller subproblems (blended particles of pigment) until you reach the base case (a seamlessly diffused gradient).

Here‘s what the recursive pseudocode for eyeshadow blending might look like:

function blend_eyeshadow(brush, pigment_particles):
  if pigment_particles are seamlessly diffused:
    return
  else: 
    apply brush to pigment_particles
    blend_eyeshadow(brush, smaller_pigment_particles)

Each time the function calls itself, it‘s working on a slightly smaller area of pigment particles until it reaches the point of perfect blending.

In contrast, an iterative approach to eyeshadow blending would be like using a fixed number of brush strokes to blur out the edges. It‘s a more linear process that doesn‘t necessarily adapt to the specific needs of the area being blended.

function blend_eyeshadow(brush, num_strokes):
  for i from 1 to num_strokes:
    apply brush to eyeshadow edges

Both recursion and iteration have their uses in programming and in eyeshadow. Sometimes a simple loop is all you need to get the job done, while other times a more adaptive recursive approach is required to handle complex edge cases.

As a programmer and an eyeshadow enthusiast, I‘ve found that thinking recursively has made me better at both crafts. Breaking down a complex problem or a multi-shade eyeshadow look into smaller subproblems is a valuable skill that transfers across domains.

Color Theory, Algorithms, and Eyeshadow Looks

Another area where programming and eyeshadow artistry intersect is in the use of color theory and algorithms to create pleasing and harmonious designs.

In UI/UX design, developers use color theory principles to choose palettes that are both aesthetically appealing and functionally effective. Colors are chosen based on factors like contrast, complementarity, and emotional impact.

Similarly, in eyeshadow, colors are chosen and combined based on artistic color theory principles. Many eyeshadow palettes are designed around complementary colors, analogous colors, or monochromatic schemes.

For example, the Anastasia Beverly Hills Soft Glam palette features a range of warm-toned neutrals and pops of pink and gold that create a harmonious and balanced color story.^3 The shades are carefully curated to work well together and create a variety of looks.

Choosing eyeshadow shades to create a specific look is like using an algorithm to solve a problem. You start with a set of inputs (the available shades), apply a set of rules and heuristics (color theory principles and personal preferences), and generate an output (the final eyeshadow look).

Here‘s what the pseudocode for a "smoky eye" eyeshadow algorithm might look like:

function create_smoky_eye(palette):
  base_shade = choose_light_neutral_shade(palette)
  transition_shade = choose_midtone_cool_brown_shade(palette)
  crease_shade = choose_dark_gray_or_black_shade(palette)
  shimmer_shade = choose_metallic_shade_for_pop(palette)

  apply_shadow(base_shade, all_over_lid)
  apply_shadow(transition_shade, above_crease)
  apply_shadow(crease_shade, outer_corner_and_crease)
  apply_shadow(shimmer_shade, center_of_lid)
  blend_edges(fluffy_brush)

This algorithm takes in an eyeshadow palette as input, selects shades based on specific criteria, and applies them in a predefined order to create a smoky eye look. The specific shades chosen may vary based on the contents of the palette, but the overall structure of the algorithm remains the same.

Of course, just like in programming, there are often multiple ways to achieve the same end result. Different people may have their own preferred eyeshadow algorithms or techniques that work best for their eye shape, skin tone, and personal style.

The key is to understand the underlying principles and then adapt and optimize based on your specific needs and goals. Experimentation and iteration are essential in both eyeshadow and coding.

Designing an Eyeshadow Web App

To put these ideas into practice, I recently designed and built a web app to help people discover new eyeshadow color combinations and get step-by-step application instructions. The app, called ShadowPlay, allows users to explore different eyeshadow looks and virtually "try on" different palettes.

From a programming perspective, building ShadowPlay required leveraging skills and techniques from across the stack. On the front-end, I used React to create a dynamic and interactive user interface that could efficiently render different eyeshadow palettes and looks.

The React component hierarchy mimics the structure of an eyeshadow look, with smaller shade components being composed together to form a complete palette component. This modular architecture made it easy to swap out different shades and looks without having to rewrite the entire UI.

On the back-end, I used Node.js and Express to build a RESTful API that could handle requests for eyeshadow data and serve up the appropriate content to the front-end. I used MongoDB as the database to store information about different eyeshadow palettes, shades, and looks.

Designing the data models for ShadowPlay was an interesting challenge. I wanted to capture the essential properties of an eyeshadow shade (color, finish, intensity) while also modeling the relationships between shades and palettes.

Here‘s a simplified version of the Shade schema in Mongoose (a MongoDB object modeling library):

const ShadeSchema = new Schema({
  name: String,
  hex: String,
  finish: {
    type: String,
    enum: [‘matte‘, ‘shimmer‘, ‘glitter‘]
  },
  intensity: {
    type: String,
    enum: [‘light‘, ‘medium‘, ‘dark‘]
  },
  palette: {
    type: Schema.Types.ObjectId,
    ref: ‘Palette‘
  }
});

The ref field on the palette property defines a relationship between the Shade and Palette models. This allows me to easily populate a palette with its associated shades and perform more complex queries.

For example, to find all shades with a "shimmer" finish in the "Naked Honey" palette, I could do something like this:

Shade.find({ palette: nakedHoneyId, finish: ‘shimmer‘ })

By leveraging the power of MongoDB‘s query language and Mongoose‘s abstraction layer, I was able to create a flexible and expressive data model that could adapt to the needs of the application.

Of course, building ShadowPlay wasn‘t without its challenges. Integrating the front-end and back-end required careful planning and robust error handling. I also had to optimize the performance of the app to ensure that it could handle a large number of eyeshadow combinations and user requests.

But by breaking down the problem into smaller subproblems and leveraging my skills as a full-stack developer, I was able to create a tool that combines my passion for eyeshadow with my love of coding.

Conclusion

In the end, what I‘ve learned from my adventures in eyeshadow and coding is that the two disciplines are more alike than they are different. Both require a keen eye for detail, a willingness to experiment and iterate, and a deep understanding of the underlying principles and techniques.

Whether you‘re blending out the perfect smoky eye or refactoring a complex codebase, the key is to break down the problem into smaller subproblems and approach it with a creative and analytical mindset.

As Kevyn Aucoin, the famous makeup artist and author, once said:

"Makeup is about creativity and having fun. It‘s not about perfection."

I believe the same is true of programming. It‘s not about writing perfect code on the first try, but rather about exploring new ideas, learning from your mistakes, and constantly improving your craft.

So whether you‘re a seasoned developer or a makeup enthusiast, I encourage you to embrace the parallels between these two fascinating fields. Who knows what insights and inspiration you might discover?

I‘ll leave you with a final thought:

"The world is your palette. Code it. Shade it. Make it beautiful."

References