Sharing a post here https://medium.com/hackernoon/feels-like-faster-vs-makes-us-faster-828686facc7e
This blog post reminded me to write down my argument against using heavy process to do planning. “The Case for ‘Developer Experience‘” or full link https://future.a16z.com/the-case-for-developer-experience/?
This particular quote is my inspiratioin
So if I were to coin a law, it would be this: Any system of sufficient size and maturity will always involve multiple languages and runtimes. Software is heterogeneous, and until we as a community accept this fact, we’re upper-bounding how far we can get with developer experience. I call this The Software Heterogeneity Problem, and it has significant consequences for software development, management, and performance.
I’ve argued that building software is much more of an Art than Science. The teams who follow the agile manifesto strictly over plan this artistic endevor of birthing software from nothing with T-shirt sizing, rule of thumb and or fibonacci numbers in 2 week increments of a sprint. What I’ve observed in the real world of software engineering in 20 years is that during the planning and estimation process:
- engineers who are inexperience would over promise (under estimate) and work over time in order to meet their deadlines, thereby burning out or over time they learn to pad their estimates.
- senior engineers would know to pad their estimates by an order of 2X because they know from experience that they will encounter unknowns during implementation no matter how much time they spend up ahead to do story breakdowns.
- for all engineers, they are held to their original estimates (even though they are told they are not) so they try their best to deliver what they promise in the short 2 week sprint cycle. What happens with unexpected discoveries?
- If they had to cut corners to make the delivery : They would file a technical debt for themselves or worst yet, for another team member, to fix later.
- They are unable to deliver what they promised and the ticket gets carried over to the next artificial sprint. This is not a problem, unless the next sprint: the team decides their left over work is not a priority anymore and the cost of context switch in future sprints now becomes a huge mental overhead. Even worst if someone else other than the author has to take over the left over work
My recommendation for high performing software engineering teams is to try:
- Engineering managers: Build the trust with engineers, empower them to make smart choices.
- Give them the ownership of a feature over a reasonable long period of time (like 3 months or quaters) and trust that they will deliver what they promise.
- Give them the freedom do all the discovery, breakdown, don’t let a tech lead or anyone else do it for them
- Using the sprint structure for them demo, work and break down dependencies and a candance and milestone to check in
- Ignore sprint to sprint estimations (don’t do them at all)
Some disclaimer and background here
- I have been an individual contributor much longer than an engineering manager. As an IC I was part of a team of 2, back in 1990’s, and we built and deliver on the #1 website in the world with Yahoo! News serving 100 million users. As a team lead of 12+, we have delivered many production websites with unmovable deadlines such as multiple US elections. As an architect for 300+ engineers, we deliver on infrastructure and platform products for 130+ websites internally.
- As an engineering manager, I’ve worked on internal tooling without artificial deadlines, so my view could heavily biased.
- As an IC I’ve build tools that have endured with the highest NPS scores humanly possible at 81. The best tool I have built and my top engineers have built were don’t without the sprint structure.
What portion of your team’s time is spent planning vs. designing and writing and testing software?
Even when you did a great job in planning, how often is your plan exactly on target?
When you hit the target of what you plan after 3 months, is that plan still the right thing to solve?
My team recently had an idea for a metasearch engine. We had a vision document, explored different options to solve the problem, and then did a 2-day hackathon. With zoom audio, 4 engineers, and 43 pull requests later, we have a working prototype that answered these questions.
- Is this a viable solution? – YES
- What are the major components?
- React Front End, Vault security key storage, API multiplexer, Express routing server.
- What are the unanswered questions?
- How does frontend filtering work for content? Does this really work to filter content?
- How does the UX work when thousands of content pieces return?
- How do we add analytics to improve the search results?
Our hackathon’s team outcome was that we learned to work with each other much better, intensely with 43 pull requests. The 4 people have a better sense of ownership and understanding of the technical and product vision. The team is much more excited to move forward with the next steps.
What we need to solve?
- How much to plan
- How to replicate the energy we had during the Hackathon
- How do we allocate more time for intense working
As software engineers, our job is to create useful services for other humans or other services that depend on our services.
In the idealized world, we write software, deploy, and move on.
In the real world, we have to think about
- Writing software
- Debugging our own software for bugs
- Testing it locally for the change, but also for any dependencies
- Writing test code to validate our change (this sometimes is bigger than then change we made)
- Submitting it for review and address the feedback from other engineers, much like writers and editors
- Deploying it to a test and staging environment to show others
- Deploying it to a canary environment to a small set of customers to exercise it, watching metrics to ensure our software worked as expected. Working with the System Reliability Engineers, make sure the impact to customers is as expected.
- Writing monitoring for our software change
- Being on call to support our change and changes made to other engineers on our team and beyond our team.
- Deploying our changes to the production environment where live customers can interact with it.
- Collecting feedback and creating and managing a backlog for future changes.
- As the systems grow larger, the original code that we wrote may be considered a legacy of technical debt as the environment changes. There could be security, scale, coverage concerns that need to be addressed.
This is the world of a software engineer beyond just writing code. As an engineer writes more code, they have more ‘legacy’ to support. For an engineer to be effective, what they create needs to be continually groomed and tend to. How they enable others to help is an important factor to help them scale. How they enable their future self to look at code they had written 1-2 years ago can be done through rigorous automated testing and up to date document and knowledge sharing.
As a developer, why test manually when you can have the machine do it for you for UI testing?
Check out Saucelabs.com and Sauce Connect here
At work when I am interviewing for candidates to join my team for Engineering Productivity, I look for certain attributes.
Having an opinion based on authority and experience
I am looking for someone with one or two areas of deep expertise. Also you should have a strong opinion but here is the kicker, you need to be willing to listen to another opinion. Diversity of opinion, recognizing that there is another perspective and be willing to listen.
Be able to talk about a topic and deep dive.
When answering a question, I will continue to push you to explain or expand deeper. I want to discover how deep you know a subject matter.
Know how to communicate which means listening
I will let you talk and respond for as long as you want, in the meantime I am looking for how long you talk non stop before checking in and see if you have answered my questions. Part of communication is listening.
Each Of Us Has A Part of The Solution, Together We Have The Whole!
Splunk is a company of thousands of talented individuals, distributed across product development offices in 8 offices in the U.S., AUNZ, Europe, and Asia.
How do we do our best work collectively and continue to push innovation while expanding at hypergrowth rate? How do we overcome the boundaries of timezone, physical location, and organization rigidity in order to create the most innovative products and solutions for our customers?
After working on Engineering Productivity at Splunk for the last 3 years, I struggled to understand WHY I chose which projects I devote time and attention to. There was a common thread, there was something there to the madness.
The list of seemly random efforts all have some type of common theme that my beloved wife, Katherine point out this weekend when I ask her for her always piercingly accurate perspective.
Here is the laundry list of random efforts:
- GO URL Shortner – Community bookmarking
- Founding Engineer bootcamp – 6 hours of hands on workshops
- Founding #weekly-tech-talks – weekly tech talks for thousands of engineers
- Starting engineering book of the quarter – 2 books per quarter to every engineer
- Founding Friday Tips – Weekly technical tips from Tony’s perspective
- Starting #ama-[any person] and starting the first #ama-with-VP-eng
- Voice Of The Customer – Bring in customers to talk to engineers about use cases
- Founding and participated in numerous Slack communities (#bookclubs, #coffee-geeks, #badminton, #women-in-tech, #hackathons, #women-engineers, #noob-splunk-eng)
- Mentoring 8+ engineers (7 female engineers and 1 male) – Intentional choice
- Writing technical documentation on how to get things done
- Tools to enable engineers to publish, write more docs and be found
- Answering questions on Slack
- Founding of impactfulengineer.org – Inspiring Engineers Through Interviews With Engineering Leaders
- #eng-blog – public Splunk Engineering blog
- Bringing in world-renowned technical speakers
- Helping with really random questions from engineers (helping to advocate for a East Bay shuttle from Dublin to San Francisco)
In my next post, I will try to talk about the common themes I have identified
- Building Communities
- Working and Thinking In Open
- Continuous Learning & Growth Mindset
- Amplify and Leverage
- Diversity Leads To The Best Solutions
- Breaking Down The Silos
Photo: Calder & Picasso exhibition in Paris 2019
Amazon popularized the silent meeting
- No powerpoints
- Send a 5 pager ahead of time
- Sit in the meeting for 20 minutes to read and comment
- Then open up for discussion
Give this a read on medium.com
“Silent Meetings” are meetings where most of the time is spent thinking and discussing the topics at hand. Functionally, they are based around a “Table Read” that everyone at the meeting reads silently, comments in and then discusses. An assigned facilitator leads the comment synthesis and discussion to ensure the meeting is valuable.
6 offices in San Francisco, Santana Row, Vancouver, Seattle, United Kingdom, Boulder and Sydney are received 145 copies of 3 books.
Pragmatic Programmer, The Code Complete & 97 Things Every Architect Should Know.
Happy reading fellow engineers!
(The photo is one of my favorite pencils I borrow from my daughter. I finally used up all the lead in the pencil)
20 minutes, that’s all it takes. “Could you show me how you work?” Let’s turn on screen capture. Oh, interesting, what else? Why do you like this over, let’s say this other thing X?
Oh, that’s interesting you do it this X way. I always thought people doing it the Y way.
(This post is not for you, it’s for me)
It started out as 5% of my time. Just a 4-hour hands-on workshop with new hires once a month. Now it’s the following
- 1 engineer working on developing a hands-on workshop that will track start, finish, and verification. Able to track usage, validate answers and replace getting started guides written on wiki pages.
- the same engineer running 2 hour bootcamp every other week, and 6 hour bootcamp every other week.
- same engineer managing developer compilation farms
- a principal engineer developing deep learning courses, coding styles, prototyping common tools, writing doxygen documentation inline to help hundreds of engineers learn our code base better
- nifty tools used by engineers daily (url shorteners, license key servers, documentation servers, common docker image build)
- Friday tips written for developers to get stuff done
- Weekly tech talks series (ML, Internal)
- Piloting apprenticeship programs to bring non-traditional CS programs
- Managing learning paths
- Managing Saucelabs relationships
- Prototyping tools to learn more about the pull request data
- Managing mentorship programs for women in tech, as well as company wide mentorship, helping with deep and focused mentorship programs
- Running area mentorship programs
- Recording and distributing other deep dive technical talks
- Engaging with Learning and Development to work on learning initiatives for engineers.