Engineering culture

Engineering Culture
What is it? What makes it great?
Wednesday, October 9, 13

What I learnt in college
artiﬁcial intelligence
graphics
java data structures
algorithms
calculus
C++
databases
networking
how to write code

...What I didn’t learn
how to write code
*for a company*
communication
code reviews
conventions release process
testing
post mortems
documentation
onboarding

Different goals
College Company
Prove that we
understand a concept or
mastered a skill.
1. Create a product that makes users happy.
2. Create a codebase that’s maintainable
and not fragile.
3. Be intellectually excited by what we’re
working on.
4. Do it with limited time and resources.
As fast and lean as possible.

That’s a lot to achieve...
1. Create a product that makes users happy.
2. Create a codebase that’s maintainable and not fragile.
3. Be intellectually excited by what we’re working on.
4. Do it with limited time and resources. As fast and
lean as possible.
And that’s why culture matters.

Why should culture matter to you?

Are you about to enter the job market?
Don’t join a company just for their product.
Join for their culture.

Are you a founding engineer?
You are shaping the culture for all the engineers
that will come after you.
Make it a good one.

Are you in an established culture?
You still have the power to change the culture.
Nothing is set in stone.

My Experience

Joined when Google was X years old.
Spent 5 years in developer relations

Joined when Coursera was 5 months old.
1 year as Frontend Engineer

Joined when KA was 2 years old.
2 months (so far!) as engineer/educator.

What makes a culture?

The Engineering Lifecycle
Onboarding
Writing Code:
* Understanding existing code
* Planning your code
* Writing consistent code
* Testing your code
* Improving your code
* Releasing your code
* Monitoring your code
* Learning from bad code
while(1) {
writeCode();
}

Onboarding
Bad culture: Treats your ﬁrst week as “initiation”.
Good culture: Values getting everyone over the
beginners hump with as many resources as possible.

On-boarding
Monday:
Morning:
- Talks: Overview, HR
- Take Photos for Team Page
Lunch: Show & Tell
Afternoon:
- Talk: Backend Architecture
- Talk: Frontend Architecture
- Talk: Code Review Process
- Deploy ﬁrst change together!
- Meet your team
Tuesday:
- Work on a small change
- Deploy small change
Wednesday-Friday:
- Pick ﬁrst big project
- Brainstorming meetings
with designers
- Begin working on it!

On-boarding
https://sites.google.com/a/khanacademy.org/forge/for-khan-employees/-new-employees-onboard-doc/developer-setup
Self-paced on-boarding:
On-demand help:

Understanding
the current code
Bad culture: Expects everyone to just “ﬁgure it out.”
Good culture: Values over-communication about what
the code does, and why it does it that way.

Comments
# Deprecated - this is true if the problem was done while in
# context-switching topic mode, which has since been removed from the site.
# TODO(benkomalo): Remove when all references are dead
topic_mode = db.BooleanProperty(indexed=False, default=False)
def consume_optional_goog_info(self, goog_user):
"""Assigns user information from Google to this UserData.
Does not call put() on this entity and expects callers to do so.
Args:
goog_user An instance of google.appengine.api.users.User
Returns: whether or not fields were consumed and this entity was modified
"""
import feature_flags.infection # sad circular dependency fix :(
"""Holds UserData, UniqueUsername, NicknameIndex
UserData: database entity holding information about a single registered user
UniqueUsername: database entity of usernames that've been set on profile pages
NicknameIndex: database entity allowing search for users by their nicknames
"""
module
function
TODOs + deprecation
Sadness

High-level Docs
http://blog.pamelafox.org/2013/07/rewriting-django-admin-in-backbone.html
http://blog.pamelafox.org/2013/03/rewriting-our-forums-with-backbone.html
http://www.youtube.com/watch?v=hgZWMSDl0P8

Writing consistent code
Bad culture: Doesn’t care how the code is written, as
long as it works.
Good culture: Values a codebase where the code
looks the same and seems to all belong together.

https://sites.google.com/a/khanacademy.org/forge/for-developers/styleguide
>> git commit
Linting...
LINT OKAY: No lint problems
Guides
Tools
+
Language Style

Design Style
• coursera: com
•
http://khanacademy.org/style
Guides Re-usable CSS+
// Typography
@baseFontSize: 13px;
@baseFontFamily: MuseoSans300,
"Helvetica Neue", Helvetica, Arial, sans-
serif;
@baseLineHeight: 22px;
@textColor: #444;
@lightTextColor: #898989;
@fontSizeTiny: 11px;
@fontSizeSmall: 12px;
@fontSizeNormal: 14px;
@fontSizeMedium: 16px;
@fontSizeLarge: 18px;
@fontSizeExtraLarge: 24px;
@fontSizeHuge: 36px;
// Buttons
@primaryButtonBackground: #89b908;
@primaryButtonBorder: #76a005;
@buttonTextColor: lighten(@grayDark,
15%);
@buttonBorderRadius: 3px;

Best Practices
http://blog.pamelafox.org/2013/07/a-guide-to-writing-backbone-apps-at.html
http://blog.pamelafox.org/2013/08/javascript-ui-library-design.html
Architecture
Tools/Libraries
APIs
...and tons more.

Writing consistent code
Do you follow standard conventions for every
language in their stack?
Do you have your own conventions for the
frameworks you use?

Testing your codeTesting your code
Bad culture: Expects you to write “safe” code, that’s
magically free of bugs because you’re all so smart.
Good culture: Realizes that tests are the key to a
stable and maintainable codebase.

Backend: Python/Django unit tests
Testing Code
http://blog.pamelafox.org/2013/06/testing-backbone-frontends.html
Frontend: Mocha/Chai/JSDom
Integration: Selenium*
Manual: QA Process, Engineer, and Team
Automated tests CI
+

Testing Code
Test education
Test engineers
http://googletesting.blogspot.com/2007/01/introducing-testing-on-toilet.html
https://www.google.com/about/jobs/search/#!t=jo&jid=35182&

Testing your codeTesting your code
Are there any tests?
What kind of tests?
How often are the tests run?
Is there a testing requirement for new features?
Is there a testing engineer or testing team?

Improving your code
Bad culture: Gives you no feedback on your code or
gives you non-constructive criticism on your code.
Good culture: Recognizes that code reviews are a
great way for everyone to learn from each other.

Code Reviews
http://phabricator.org/
>> arc diff
>> arc land --onto master
Tools

Code Reviews
https://sites.google.com/a/khanacademy.org/forge/for-developers/code-review-policy
+ Docs

Improving your code
Are code reviews a part of the engineering process?
Are code reviews *required*?
What tool do you use for code reviews?

Releasing your code
Bad culture: Makes it hard to release code early and often.
Good culture: Enables everyone to release their code
with minimal time and pain.

Release Process
http://betacs.pro/blog/2013/07/06/wayland/
8 minutes to deploy
2 minutes to rollback

Releasing your code
How often is code deployed?
How fast is the process?
How fast is the rollback?
Who's in charge of a deploy?

Monitoring your code
Bad culture: Releases code without paying attention to
how it fares in the wild.
Good culture: Recognizes the value of logging, alerts,
and user feedback mechanisms to ensure code validity.

Monitoring
Backend
monitoring
+
Alerts

Monitoring
Frontend
monitoring
User feedback alerts

Monitoring your code
Are backend and frontend errors monitored?
Are there user feedback mechanisms?
Are there smart alerts set up?

Learning from bad code
Bad culture: Sweeps mistakes under the rug, refusing to
acknowledge or learn from them, or blames them on a
bad coder.
Good culture: Realizes that mistakes are an opportunity
for the *whole team* to learn and improve.

Post-Mortems
• Timeline of events
• What went wrong?
• What went right?
• What speciﬁc action items would prevent this
from happening in the future?
https://groups.google.com/forum/#!topic/google-appengine/p2QKJ0OSLc8
Don’t blame. Learn.

Post-Mortems
• Coding bugs: “The Mass Unenrollment”
• Server faults: “The Overloaded Database”
• Security issues: “Cross-site-scripting in PHP”
• Process ﬂaws: “The Class Recyling Project”

Learning from your code
When bad decisions are made in code, how does
the the team learn from them?

Now what?
Learn from others
Share with your team
Experiment
Share with others
“Team Geek” by Fitzpatrick and Collins-Sussman
http://blog.pamelafox.org/2013/07/what-to-look-for-in-software.html
http://www.joelonsoftware.com/articles/fog0000000043.html

The culture matters as
much as the product.

THAR! Here be dragons!

Planning your code
Bad culture: Expects great code to emerge with no
thought or collaboration.
Good culture: Values the process of planning code.

Design Docs
• google template?
• can happen in a jira discussion

Design Discussions
• whiteboard

Engineering culture

More Related Content

Viewers also liked

Similar to Engineering culture

More from Pamela Fox

Recently uploaded

Engineering culture