The Curious Incident of the Developer in the Design Team: Thinking in the Same Language
Are you spending more time arguing than implementing? Gain insight into the inner workings of Twilio’s unique cross-functional team of designers and developers who can talk the same language. Danielle and Nina will illustrate how they compliment each others’ skill sets and leverage their differences to benefit the user. This talk will showcase how they collaborate and build a great product from sketch to ship.
Danielle Leong - Twilio, Front End Web Developer
Nina Mehta - Twilio, Interaction Designer
I’ve been using, teaching, and evangelizing about jQuery for years. The library's simplicity is seductive; after a while, it kind of writes itself. So why did I venture into the unknown world of Dojo for a recent project? Find out what I learned about JavaScript code organization, inheritance, dependency management, and more in a whirlwind beginner's tour of a toolkit that answers some of the big questions surrounding JavaScript development.
When you move beyond adding simple enhancements to your website with jQuery and start building full-blown client-side applications, how do you organize your code? At this month's Triangle JS Meetup, we'll take a look at patterns for application development using jQuery that promote the principles of tight encapsulation and loose coupling, including classes, the publish/subscribe paradigm, and dependency management and build systems.
The magic of jQuery's CSS-based selection makes it easy to think about our code in terms of the DOM, and sometimes that approach is exactly right. Other times, though, what we're trying to accomplish is only tangentially related to our nodes, and opting for an approach where we think in terms of functionality -- not how that functionality is manifested on our page -- can pay big dividends in terms of flexibility. In this talk, we'll look at a small sample application where the DOM takes a back seat to functionality-focused modules, and see how the approach can change the way we write and organize our code.
The document describes a mobile app development toolkit called Mulberry that includes:
- A command line interface that creates an app structure with necessary files
- An application framework for JavaScript, HTML templates, and CSS
- A builder that generates production-ready builds for Android and iOS
- Tools for managing routes, components, capabilities, stores, and page definitions to build the app functionality and interface
Dieter Rams is a German industrial designer known for his work with Braun products in the postwar era. He followed the principle of functionalism, which emphasizes simple, undecorated forms that clearly express a product's use. Rams developed ten principles of good design that emphasize innovation, usefulness, aesthetics, understandability, honesty, durability, attention to detail, consideration of the environment, and minimal design. His designs for Braun, including radios, juicers, and audio equipment, helped establish the Functionalist school and had a long-lasting influence on product design.
10 Principles of Design by Dieter Rams for Data VisualizationMika Aldaba
Guest Lecture for the Data Visualization class at Ateneo de Manila University. Basic design principles for Computer Science students. For educational purposes only, no copyright infringement intended.
Less, But Better - Dieter Rams' Principles of Good Design3Pillar Global
A presentation from 3Pillar Senior UX Designer David Rhyne on Dieter Rams' 10 Principles of Good Design. Among the principles put forward by Rams as most important to design are that it is innovative and makes a product useful and understandable.
Most of us started with patterns by Eric Evans and others. This helped us build models using Object Orientated Design and we have grown to appreciate the value of patterns such as Aggregate and Value Object. This talk looks forward and consists of various attempts to push our boundaries towards a more declarative way of domain modelling. We will look at a functional and logic based approach to design, where the statement of the requirement is the model itself. Apart from the variable choices in programming languages, the thinking tools that arise from this helps reduces the impedance between programmers and domain experts. The intention of this talk is to share, generate conversation so that we move forward as a community.
I’ve been using, teaching, and evangelizing about jQuery for years. The library's simplicity is seductive; after a while, it kind of writes itself. So why did I venture into the unknown world of Dojo for a recent project? Find out what I learned about JavaScript code organization, inheritance, dependency management, and more in a whirlwind beginner's tour of a toolkit that answers some of the big questions surrounding JavaScript development.
When you move beyond adding simple enhancements to your website with jQuery and start building full-blown client-side applications, how do you organize your code? At this month's Triangle JS Meetup, we'll take a look at patterns for application development using jQuery that promote the principles of tight encapsulation and loose coupling, including classes, the publish/subscribe paradigm, and dependency management and build systems.
The magic of jQuery's CSS-based selection makes it easy to think about our code in terms of the DOM, and sometimes that approach is exactly right. Other times, though, what we're trying to accomplish is only tangentially related to our nodes, and opting for an approach where we think in terms of functionality -- not how that functionality is manifested on our page -- can pay big dividends in terms of flexibility. In this talk, we'll look at a small sample application where the DOM takes a back seat to functionality-focused modules, and see how the approach can change the way we write and organize our code.
The document describes a mobile app development toolkit called Mulberry that includes:
- A command line interface that creates an app structure with necessary files
- An application framework for JavaScript, HTML templates, and CSS
- A builder that generates production-ready builds for Android and iOS
- Tools for managing routes, components, capabilities, stores, and page definitions to build the app functionality and interface
Dieter Rams is a German industrial designer known for his work with Braun products in the postwar era. He followed the principle of functionalism, which emphasizes simple, undecorated forms that clearly express a product's use. Rams developed ten principles of good design that emphasize innovation, usefulness, aesthetics, understandability, honesty, durability, attention to detail, consideration of the environment, and minimal design. His designs for Braun, including radios, juicers, and audio equipment, helped establish the Functionalist school and had a long-lasting influence on product design.
10 Principles of Design by Dieter Rams for Data VisualizationMika Aldaba
Guest Lecture for the Data Visualization class at Ateneo de Manila University. Basic design principles for Computer Science students. For educational purposes only, no copyright infringement intended.
Less, But Better - Dieter Rams' Principles of Good Design3Pillar Global
A presentation from 3Pillar Senior UX Designer David Rhyne on Dieter Rams' 10 Principles of Good Design. Among the principles put forward by Rams as most important to design are that it is innovative and makes a product useful and understandable.
Most of us started with patterns by Eric Evans and others. This helped us build models using Object Orientated Design and we have grown to appreciate the value of patterns such as Aggregate and Value Object. This talk looks forward and consists of various attempts to push our boundaries towards a more declarative way of domain modelling. We will look at a functional and logic based approach to design, where the statement of the requirement is the model itself. Apart from the variable choices in programming languages, the thinking tools that arise from this helps reduces the impedance between programmers and domain experts. The intention of this talk is to share, generate conversation so that we move forward as a community.
The document discusses Tracy Lee's presentation on reactive programming with RxJS. It provides an agenda for topics to be covered, including reactive programming in standards, frameworks and libraries, how to think reactively, what RxJS is, and how reactive programming makes development easier. Key points mentioned are promises and observables in standards, reactive programming support in Angular, React, Vue, and D3, treating all applications and data as event-driven and represented as sets of values over time, and that RxJS is the most popular library for reactive programming that provides observables as a way to react to and handle events.
You're organised, you love spreadsheets, you're a great cheerleader, you handle a backlog with superhero skills, and now you're faced with managing a Drupal project and everything just feels foreign. It's not you, it's Drupal. The mix of site building, front end development, backend development, and over 20,000 contributed modules makes project management for Drupal exceptionally frustrating for people who've not worked with Drupal before.
This session will cover:
- the basic Drupal development workflow (from a developer's perspective, but without using developer jargon)
writing useful tickets which developers can accomplish
- estimation tips for multi-discipline tickets (design / back end / front end)
- ideal team structures -- and what to do if you can't get them
Updated from DrupalCamp London to include the truisms I've learned about being a first-time project manager.
Drupal 8: A story of growing up and getting off the islandAngela Byron
The document discusses Drupal's transition from Drupal 7 to Drupal 8. It describes how Drupal 8 modernized by adopting PHP best practices like Composer, OOP, and external libraries. This required rewriting large parts of the codebase. The transition was challenging due to technical debt from the past and fears about change. Lessons learned include setting goals, gaining buy-in through transparency, incremental changes, and addressing fears through support. While the transition is not complete, Drupal 8 has rejoined mainstream PHP development practices.
The document discusses object-oriented concepts in Java including objects, classes, constructors, encapsulation, and Java source file layout. It defines objects as anything real or conceptual and classes as blueprints for objects. Constructors are special methods that initialize objects. Encapsulation hides implementation details and protects data using private attributes with public getters and setters. The Java source file layout follows a PIC order of package, import, classes. It also discusses creating JAR files to package related class files together.
Mehar Singh, CEO of ProCogia, and Jason Grahn, Senior Business Analyst at Apptio, co-present on the journey from Excel to R at the second Bellevue chapter useR Group Meetup.
If we’re producing analysis that drives business decision making, that’s production-grade code! This talk will address this question, which in turn shows why R is the way to go – assumptions are built into the code and enables the analyst to automate & reproduce their efforts.
This presentation includes:
- Data importing (opening a CSV or connecting to a SQL in both tools)
- Filtering, grouping, summarizing (pivot tables in Excel vs. tidy code in R)
- Visualizations (charts in excel vs ggplot in R)
Laravel's Eloquent ORM is an Active Record implementation that makes working with databases almost even fun. It's simple and intuitive API is honestly a breath of fresh air.
But not everything is always roses, Eloquent can't protect you from using in ways it wasn't necessarily intended to be used. This presentation pulls examples from my own experiences and highlights some of the mistakes I've made while working with it. Each example is then refactored in a way which keeps Eloquent eloquent.
Dependency Injection Why is it awesome and Why should I care?ColdFusionConference
The document discusses dependency injection (DI), a design pattern that allows classes to be flexible and organized by managing their dependencies. It explains that DI frameworks handle object creation and injection of dependencies automatically, reducing boilerplate code. This inversion of control allows default values and relationships between objects to be configured through files rather than hardcoded in code.
This document discusses using Python for web development. Some key points:
- Python is a flexible, open source language that is well-suited for web projects due to its extensive standard library, third-party modules, and large developer community.
- Python code tends to be more readable and maintainable than other languages like Java or PHP due to Python's simplicity, readability-focused syntax, and support for functional programming patterns.
- Python web frameworks provide batteries included functionality like template engines, object relational mappers, caching, and asynchronous request handling that speed up development.
- Python's extensive standard library and ecosystem of third-party modules provide solutions for common tasks like localization, testing, debugging
In an R&D company fast prototyping is vital to develop new projects or proofs of concept quickly and inexpensively. In this talk we will demonstrate how real fast and agile development can be achieved with MongoDB and dynamic languages, with examples and best practices. All the code shown is already uploaded to a public Git repository - https://github.com/pablito56/py-eshop
This document describes Divyanshu Kumar's class 12 investigatory project on a bank management system created using C++. The project uses object-oriented programming concepts like classes, objects, inheritance and polymorphism to develop a program to manage bank accounts stored in a binary file. The program allows users to perform operations like creating new accounts, depositing and withdrawing amounts, checking balances and listing all accounts. The source code and outputs of the program are included along with an index and acknowledgements section.
Dependency injection is a design pattern that allows classes to have their dependencies satisfied externally rather than internally. It promotes loose coupling between classes and makes code more organized and flexible. Bean management allows the dependency injection framework to automatically instantiate objects and their dependencies rather than requiring manual setup. Inversion of control inverts traditional object creation by allowing external configuration to determine default property values and dependencies rather than coding them. Aspect oriented programming allows cross-cutting concerns like logging or error handling to be defined separately from the core functionality they apply to.
The document discusses using code katas and test-driven development to improve JavaScript skills, providing examples of writing tests for a parseFloat function using the Jasmine testing framework and practicing algorithms like prime factoring and the Game of Life. It emphasizes writing clean, well-tested code in pairs to internalize best practices.
The document summarizes a presentation on the Python programming language. It includes sections on introducing Python, operators and data types, conditions and loops, functions and exception handling, classes and inheritance, Python libraries, a sample library management project in Python, and queries. The presentation covers key Python concepts like data types, operators, conditional statements, loops, functions, object-oriented programming concepts like classes and inheritance, and popular Python libraries like NumPy and Pandas. It also includes code for a library management project built in Python.
This document provides an overview of objects, testing, and responsibility in software development. It discusses object-oriented programming concepts like abstraction, encapsulation, inheritance and polymorphism. It emphasizes the importance of testing and gives examples of good and bad testing practices. Responsibility is discussed in the context of objects having well-defined responsibilities and developers being responsible for writing clean, well-tested code.
This document outlines an agenda for a Python tutorial session, beginning with an introduction to Python's motivation and essentials like data types, operators, and flow control. It then provides examples of expressions, variables, and basic data structures like lists, tuples, and dictionaries. The session demonstrates Python blocks like conditionals, loops, functions, classes and modules. It concludes by suggesting areas for further practice like system administration, web development, and games.
This document summarizes a presentation on overcoming dysfunctional programming through functional programming techniques. It discusses:
- Who the presenters are and their backgrounds in agile coaching.
- An agenda that includes introductions to functional programming terms, using FP in existing code, improving designs with FP, and a recap.
- Key FP concepts like pure functions, higher order functions, and avoiding side effects.
- Ways FP can be used to refactor common patterns like command and state patterns.
- Benefits of FP like testability, error handling, and concurrency, but also challenges of adopting it with teams.
The document discusses the module pattern, a design pattern for creating reusable components in JavaScript. It describes how the module pattern allows simulating privacy by wrapping code in immediately invoked function expressions (IIFEs) and returning objects instead of functions. This creates a private scope that is not accessible globally while exposing public APIs. Several examples are given of how different libraries like Dojo, jQuery, YUI, and ExtJS implement the module pattern.
This document provides an overview of dependency injection and related concepts like inversion of control and aspect oriented programming. It discusses what dependency injection is, when and why to use it, and examples of how it can make code more organized and flexible. Specifically, it explains how dependency injection frameworks can manage object creation through configuration rather than code, allowing dependencies to be easily swapped. It also describes how inversion of control "flips" code to externalize default values and dependencies, and how aspect oriented programming allows cross-cutting concerns to be modularized.
The document provides an agenda for a presentation on DataWeave fundamentals. It introduces DataWeave as a domain-specific language for data transformations. The presenter explains that DataWeave is a fully-fledged programming language that follows functional programming principles. Key aspects of functional programming covered are immutable data, pure mathematical functions, and using expressions instead of statements. Practical tips discussed include understanding functions are central to DataWeave and not giving up when learning the paradigm shift to functional programming.
International Upcycling Research Network advisory board meeting 4Kyungeun Sung
Slides used for the International Upcycling Research Network advisory board 4 (last one). The project is based at De Montfort University in Leicester, UK, and funded by the Arts and Humanities Research Council.
The document discusses Tracy Lee's presentation on reactive programming with RxJS. It provides an agenda for topics to be covered, including reactive programming in standards, frameworks and libraries, how to think reactively, what RxJS is, and how reactive programming makes development easier. Key points mentioned are promises and observables in standards, reactive programming support in Angular, React, Vue, and D3, treating all applications and data as event-driven and represented as sets of values over time, and that RxJS is the most popular library for reactive programming that provides observables as a way to react to and handle events.
You're organised, you love spreadsheets, you're a great cheerleader, you handle a backlog with superhero skills, and now you're faced with managing a Drupal project and everything just feels foreign. It's not you, it's Drupal. The mix of site building, front end development, backend development, and over 20,000 contributed modules makes project management for Drupal exceptionally frustrating for people who've not worked with Drupal before.
This session will cover:
- the basic Drupal development workflow (from a developer's perspective, but without using developer jargon)
writing useful tickets which developers can accomplish
- estimation tips for multi-discipline tickets (design / back end / front end)
- ideal team structures -- and what to do if you can't get them
Updated from DrupalCamp London to include the truisms I've learned about being a first-time project manager.
Drupal 8: A story of growing up and getting off the islandAngela Byron
The document discusses Drupal's transition from Drupal 7 to Drupal 8. It describes how Drupal 8 modernized by adopting PHP best practices like Composer, OOP, and external libraries. This required rewriting large parts of the codebase. The transition was challenging due to technical debt from the past and fears about change. Lessons learned include setting goals, gaining buy-in through transparency, incremental changes, and addressing fears through support. While the transition is not complete, Drupal 8 has rejoined mainstream PHP development practices.
The document discusses object-oriented concepts in Java including objects, classes, constructors, encapsulation, and Java source file layout. It defines objects as anything real or conceptual and classes as blueprints for objects. Constructors are special methods that initialize objects. Encapsulation hides implementation details and protects data using private attributes with public getters and setters. The Java source file layout follows a PIC order of package, import, classes. It also discusses creating JAR files to package related class files together.
Mehar Singh, CEO of ProCogia, and Jason Grahn, Senior Business Analyst at Apptio, co-present on the journey from Excel to R at the second Bellevue chapter useR Group Meetup.
If we’re producing analysis that drives business decision making, that’s production-grade code! This talk will address this question, which in turn shows why R is the way to go – assumptions are built into the code and enables the analyst to automate & reproduce their efforts.
This presentation includes:
- Data importing (opening a CSV or connecting to a SQL in both tools)
- Filtering, grouping, summarizing (pivot tables in Excel vs. tidy code in R)
- Visualizations (charts in excel vs ggplot in R)
Laravel's Eloquent ORM is an Active Record implementation that makes working with databases almost even fun. It's simple and intuitive API is honestly a breath of fresh air.
But not everything is always roses, Eloquent can't protect you from using in ways it wasn't necessarily intended to be used. This presentation pulls examples from my own experiences and highlights some of the mistakes I've made while working with it. Each example is then refactored in a way which keeps Eloquent eloquent.
Dependency Injection Why is it awesome and Why should I care?ColdFusionConference
The document discusses dependency injection (DI), a design pattern that allows classes to be flexible and organized by managing their dependencies. It explains that DI frameworks handle object creation and injection of dependencies automatically, reducing boilerplate code. This inversion of control allows default values and relationships between objects to be configured through files rather than hardcoded in code.
This document discusses using Python for web development. Some key points:
- Python is a flexible, open source language that is well-suited for web projects due to its extensive standard library, third-party modules, and large developer community.
- Python code tends to be more readable and maintainable than other languages like Java or PHP due to Python's simplicity, readability-focused syntax, and support for functional programming patterns.
- Python web frameworks provide batteries included functionality like template engines, object relational mappers, caching, and asynchronous request handling that speed up development.
- Python's extensive standard library and ecosystem of third-party modules provide solutions for common tasks like localization, testing, debugging
In an R&D company fast prototyping is vital to develop new projects or proofs of concept quickly and inexpensively. In this talk we will demonstrate how real fast and agile development can be achieved with MongoDB and dynamic languages, with examples and best practices. All the code shown is already uploaded to a public Git repository - https://github.com/pablito56/py-eshop
This document describes Divyanshu Kumar's class 12 investigatory project on a bank management system created using C++. The project uses object-oriented programming concepts like classes, objects, inheritance and polymorphism to develop a program to manage bank accounts stored in a binary file. The program allows users to perform operations like creating new accounts, depositing and withdrawing amounts, checking balances and listing all accounts. The source code and outputs of the program are included along with an index and acknowledgements section.
Dependency injection is a design pattern that allows classes to have their dependencies satisfied externally rather than internally. It promotes loose coupling between classes and makes code more organized and flexible. Bean management allows the dependency injection framework to automatically instantiate objects and their dependencies rather than requiring manual setup. Inversion of control inverts traditional object creation by allowing external configuration to determine default property values and dependencies rather than coding them. Aspect oriented programming allows cross-cutting concerns like logging or error handling to be defined separately from the core functionality they apply to.
The document discusses using code katas and test-driven development to improve JavaScript skills, providing examples of writing tests for a parseFloat function using the Jasmine testing framework and practicing algorithms like prime factoring and the Game of Life. It emphasizes writing clean, well-tested code in pairs to internalize best practices.
The document summarizes a presentation on the Python programming language. It includes sections on introducing Python, operators and data types, conditions and loops, functions and exception handling, classes and inheritance, Python libraries, a sample library management project in Python, and queries. The presentation covers key Python concepts like data types, operators, conditional statements, loops, functions, object-oriented programming concepts like classes and inheritance, and popular Python libraries like NumPy and Pandas. It also includes code for a library management project built in Python.
This document provides an overview of objects, testing, and responsibility in software development. It discusses object-oriented programming concepts like abstraction, encapsulation, inheritance and polymorphism. It emphasizes the importance of testing and gives examples of good and bad testing practices. Responsibility is discussed in the context of objects having well-defined responsibilities and developers being responsible for writing clean, well-tested code.
This document outlines an agenda for a Python tutorial session, beginning with an introduction to Python's motivation and essentials like data types, operators, and flow control. It then provides examples of expressions, variables, and basic data structures like lists, tuples, and dictionaries. The session demonstrates Python blocks like conditionals, loops, functions, classes and modules. It concludes by suggesting areas for further practice like system administration, web development, and games.
This document summarizes a presentation on overcoming dysfunctional programming through functional programming techniques. It discusses:
- Who the presenters are and their backgrounds in agile coaching.
- An agenda that includes introductions to functional programming terms, using FP in existing code, improving designs with FP, and a recap.
- Key FP concepts like pure functions, higher order functions, and avoiding side effects.
- Ways FP can be used to refactor common patterns like command and state patterns.
- Benefits of FP like testability, error handling, and concurrency, but also challenges of adopting it with teams.
The document discusses the module pattern, a design pattern for creating reusable components in JavaScript. It describes how the module pattern allows simulating privacy by wrapping code in immediately invoked function expressions (IIFEs) and returning objects instead of functions. This creates a private scope that is not accessible globally while exposing public APIs. Several examples are given of how different libraries like Dojo, jQuery, YUI, and ExtJS implement the module pattern.
This document provides an overview of dependency injection and related concepts like inversion of control and aspect oriented programming. It discusses what dependency injection is, when and why to use it, and examples of how it can make code more organized and flexible. Specifically, it explains how dependency injection frameworks can manage object creation through configuration rather than code, allowing dependencies to be easily swapped. It also describes how inversion of control "flips" code to externalize default values and dependencies, and how aspect oriented programming allows cross-cutting concerns to be modularized.
The document provides an agenda for a presentation on DataWeave fundamentals. It introduces DataWeave as a domain-specific language for data transformations. The presenter explains that DataWeave is a fully-fledged programming language that follows functional programming principles. Key aspects of functional programming covered are immutable data, pure mathematical functions, and using expressions instead of statements. Practical tips discussed include understanding functions are central to DataWeave and not giving up when learning the paradigm shift to functional programming.
International Upcycling Research Network advisory board meeting 4Kyungeun Sung
Slides used for the International Upcycling Research Network advisory board 4 (last one). The project is based at De Montfort University in Leicester, UK, and funded by the Arts and Humanities Research Council.
Best Digital Marketing Strategy Build Your Online Presence 2024.pptxpavankumarpayexelsol
This presentation provides a comprehensive guide to the best digital marketing strategies for 2024, focusing on enhancing your online presence. Key topics include understanding and targeting your audience, building a user-friendly and mobile-responsive website, leveraging the power of social media platforms, optimizing content for search engines, and using email marketing to foster direct engagement. By adopting these strategies, you can increase brand visibility, drive traffic, generate leads, and ultimately boost sales, ensuring your business thrives in the competitive digital landscape.
Practical eLearning Makeovers for EveryoneBianca Woods
Welcome to Practical eLearning Makeovers for Everyone. In this presentation, we’ll take a look at a bunch of easy-to-use visual design tips and tricks. And we’ll do this by using them to spruce up some eLearning screens that are in dire need of a new look.
Explore the essential graphic design tools and software that can elevate your creative projects. Discover industry favorites and innovative solutions for stunning design results.
1. THE CURIOUS INCIDENT
OF THE DEVELOPER
ON THE DESIGN TEAM
THINKING IN THE SAME LANGUAGE
We are here today to talk about improving developer/designer relationships. This talk, The
Curious Incident of the Developer on the Design Team, is how we approached the issue of
being able to think in the same language.
This talk was held on Tuesday, February 26, 2013 at Twilio HQ, 501 Folsom Street, San Francisco, CA at 6:30p.
http://www.eventbrite.com/event/4537648228
2. DANIELLE LEONG
DEVELOPER
@tsunamino
NINA MEHTA
DESIGNER
@ninamehta
Danielle Leong is a Front End Web Developer at Twilio. After graduating UC Irvine for
marketing, she taught herself to code and joined the Twilio design team as the company's first
female engineer. She specializes in responsive site and email creation, company branding,
and fights the good fight for better cross-browser compatibility. In her off time, she teaches
latin dance and bakes gourmet cupcakes. Follow her on Twitter at http://twitter.com/tsunamino
Nina Mehta works and plays at Twilio as an interaction designer. She's worked with startups
disrupting translation, investing, travel bookings and even the modern web browser. With a
former career in journalism and a Master's in HCI, Nina has done design work and research in
Tokyo, London, Cape Town and around the Bay Area. She does live visuals at clubs to explore
the broader meaning of experience and physical space design. Follow her on Twitter at http://
twitter.com/ninamehta
3. TWILIO IS CHANGING COMMUNICATIONS BY
EMPOWERING SOFTWARE PEOPLE TO BUILD
VOICE AND MESSAGING INTO ANY APPLICATION
@tsunamino @ninamehta
Danielle
Twilio is changing communications by empowering software people to build voice and
messaging into any application.
Some examples of how people use Twilio:
- Uber & Taskrabbit text notifications
- Zendesk and Hulu’s help desk call centers
- Airbnb & Match.com calls in the browser
4. SHIPPING
Danielle
At Twilio we need to ship things quickly in order to get new material into the hands of sales
and marketing. The design team sits between Marketing (the owners of the message) and
Engineering (the owners of the website). It’s our job to make sure quality things ship on time.
This created a need to bring a developer on the design team to usher the message through
from start to finish.
Photo: http://www.flickr.com/photos/automaton_be/4477406732/sizes/l/
5. A DEVELOPER ON DESIGN @tsunamino @ninamehta
Danielle
Why put a developer on design? Why not hire someone on engineering?
We needed someone to care about the message and how it was implemented on our
website. If you’re working with a developer from another team to implement designs, their
team’s priorities will always be first.
http://octodex.github.com/
6. PLAY ON THE SAME TEAM @tsunamino @ninamehta
Danielle
But what if you can’t hire a developer on your design team? What are some ways that you can
improve communication between your existing developers and designers? In order to work
well together, you need to learn your teammates’ working styles and motivators. We spent
time doing a few studies and reading about working styles of introverts and extroverts to
figure out how we all fit together as a team. Some people need certain things in order to work.
As an introvert, I need some time to focus on a problem before I present it. As an extrovert,
Nina sometimes needs to talk her ideas out loud to a person. Some common motivators we
found at work were deadlines, data, collaboration, and technical challenges.
photo: http://www.flickr.com/photos/deanmccoyphotos/5795006771/sizes/l/
7. /* CAROUSEL CLASS DEFINITION
* ========================= */
var Carousel = function (element, options) {
this.$element = $(element)
this.$indicators = this.$element.find(‘.carousel-
indicators’)
this.options = options
this.options.pause == ‘hover’ && this.$element
.on(‘mouseenter’, $.proxy(this.pause, this))
.on(‘mouseleave’, $.proxy(this.cycle, this))
}
Carousel.prototype = {
cycle: function (e) {
if (!e) this.paused = false
if (this.interval) clearInterval(this.interval);
this.options.interval
&& !this.paused
&& (this.interval = setInterval($.proxy(this.next,
this), this.options.interval))
return this
}
, getActiveIndex: function () {
this.$active = this.$element.find(‘.item.active’)
this.$items = this.$active.parent().children()
return this.$items.index(this.$active)
}
, to: function (pos) {
var activeIndex = this.getActiveIndex()
, that = this
REAL TALK if (pos > (this.$items.length - 1) || pos < 0) return
if (this.sliding) {
return this.$element.one(‘slid’, function () {
that.to(pos)
Danielle })
For our design team to work well together we also really need to understand each others’
} tools
and technical skills. This helps us ask the right(activeIndex == pos) something doesn’t look or
if
questions when {
work properly. Asking the right questions and return this.pause().cycle()
understanding each others’ processes allow us
}
to understand better when something just isn’t right. Though I don’t design things at Twilio, I
still understand creative suite, typography, layout and a good ux.
Nina
Though I don’t get into the codebase at Twilio, I know HTML, CSS and Javascript. I can work
through a complex flow with backend engineers and find out what’s possible to build and
through all phases in a design cycle. Our creative director even codes in python on the
weekends.
Knowing each others’ skills gives us a shared language that gets us through sticky
roadblocks and helps us empathize when something just isn’t working like it should.
8. CRITIQUE EARLY & OFTEN @tsunamino @ninamehta
Nina
We make sure to have formal and informal critiques every week. Because we understand
each others’ skills, it’s much easier to articulate ourselves and when looking over a project.
This help iterate on designs much faster. When a design is in the process of being built, we
can look at it together and quickly tweak details to ship something we like.
Danielle attends all design reviews so she knows how the project is supposed to look and
what it’s supposed to do before she ever starts coding. But we all have lots of meetings, so it
might not makes sense to bring developers to your design reviews. See if they can pop in
when going over one specific part of your project. Or do short but frequent recaps at design
milestones throughout the creative process.
Doing this helps everyone tell the same story and see the message through from start to
finish.
But this starts by hiring people who want to work like that.
Photo: http://farm3.staticflickr.com/2494/3742918775_f3b2aee5be_z.jpg?zz=1
9. HIRE PEOPLE YOU WANT TO WORK WITH
Nina
So find people you want to work with.
Bring on someone who not only has the right technical skills but also someone you can see on
your team. This sounds obvious, but a collaborative team knows and wants to talk each other.
This is important because you’ll need to trust they’ll do their job well but also will be willing to
work together as a team instead of in a black box. There’s no room for unicorns, gurus or
ninjas.
We found some people who applied for positions on the design team wanted to use it as a
stepping stone to other kids of work or weren’t very collaborative. We were patient and found
people with great talent that also cared about design and shared our values.
You’ll likely spend more time with these people than with your partner or roommate. Be patient
with hiring, no matter how many things are on fire. Waiting to finding great talent who wanted
to work with, was a big win for us.
11. OUR POINT @tsunamino @ninamehta
Both
Ok, so what’s the point?
The point is not to be able to do each others’ jobs.
The point is to know enough about each others’ to ask the right questions. When everyone
has their own specialities but shared knowledge, it becomes easier to make thoughtful
decisions faster.
Some things you can do:
• Start by communicating. Let people on your team know you want to understand their
process. Danielle helps me understand our codebase and frameworks, we share our
knowledge about the shipping process with marketing and our sales engineers let me sit on
calls (with permission) to learn about where our customers are getting stuck. And developers
on our engineering team now know it’s ok to ask, “how can I make this less ugly?”
• Designers, invite developers to your design reviews. The design process is often seen as a
black box. It seems like we somehow get an idea, draw a bunch of doodles, scratch our head
a few times, click and drag a few thousand times and out the other end comes “the design”.
Debunk the black box and show what’s happening in those doodles and clicks. It helps
developers understand how the design got where it is and what elements are important for
which reasons.
• Developers, pull in designers while you’re building. It’s your job to keep the project on track
but doing this can save lots of ‘design bug’ fixing at the end. It will help designers on the
team understand why and how their work gets implemented. While it sounds like it costs more
12. OH YEAH
SHOULD DESIGNERS CODE?
Nina
Should designers code?
This is debated in all kinds of Quora threads and all kinds of blogs and talks.
But we say yes. Whether or not you code for your job, you should code. Some even say,
unless you work at a very small startup, it doesn’t even make sense for designers to ship
code. But knowing how to do it can help you make prototypes to communicate your ideas
and above all ask your developer smart questions.
13. BUT
DEVELOPERS SHOULD DESIGN
Danielle
But! Developers should design.
Whether or not you design for your job, you should be able to understand the creative
process.