Recent Posts (page 13 / 65)

Careers Pt 2 – Breaking Down Scope

In Part 1 I described how your level is a proxy for scope of influence. Knowing that gives you a framework to understand where you think you are. What it doesn’t give you a way to break scope of influence down into a series of areas that you can measure.

One way to do that is break down scope into categories. Different companies call them different things. Some call them competencies, proficiencies, or areas, others might call the capabilities or skills, It doesn’t really matter what they’re called, as long as everyone is talking about the same thing. In my experience they’ll usually map to different competencies that cover these 5 areas.

Competency Breakdown

Citizenship

Citizenship is how you support the company outside of the company’s lines of business. Things like being an active interviewer, onsite and offsite, presenting on behalf of the company at a conference, or contributing to an open-source project. It’s being part of or leading an internal employee group or donation project.

Software Engineering

Software Engineering is the one of the core competencies for the engineering role. It’s about writing code and use/promoting/defining best practices. It’s building something that works now and is scalable enough to work for the future. For other roles, such as PM it would be about project management and finding customer value.

Architecture

Architecture is the other one of the core engineering competencies. Architecture is about interfaces and designs and ensuring things work when then need to can change to handle new requirements. It’s about deciding what to build, what to buy, and what to stop doing. For other roles, like PM, it will be related to the role. For them it might be about what to features to build or not build.

Execution

Execution is getting things done. Getting them done on time. Regardless of whether it’s a current, short-term project, a multi-year project or strategy, spans multiple people/teams/groups or even companies.

Collaboration

Collaboration is a measurement of how well you work with others. The people working on the same functions, the people on your team or a larger organization or in out outside of your industry.

Efficiency

Efficiency is about doing more with less. Using fewer resources, people or compute. Finding and eliminating duplications. Sharing the shareable. Automating the automatable.

Once you know what those competencies are, you need a way to measure you scope in those areas. That breaks down into two areas, time and impacted people. The breakdown for the different areas looks something like this

Time

• Immediate/Right Now
• ~ 6 months
• ~ 1 - 2 years
• 3 - 5 Years
• 5+ years

Impacted People

• Yourself
• A feature team (2 - 3 people)
• A team
• An org/division
• Your company / industry

Combined, the competencies and the scope areas give you something you can mostly measure. What you DO with those measurements and how you think about them will be covered in part 3.

Scheduling Time For Maintenance

This is a real thing you can buy.

Brady is all about labeling for the workplace. They’re primarily aimed at the manufacturing/processing space. They’ve got a product line directed at lean manufacturing techniques, such as those that come out of the Toyota Production System (TPS), which I’ve talked about before. Since a lot of today’s agile and lean software development processes are derived from TPS and lean manufacturing some of them make a lot of sense in the software world as well.

We don’t have machines or storage racks that you could put that sticker on, but putting it somewhere prominent, like on your laptop or next to your monitor, so you don’t forget about it might make sense.

But what does it really mean for software? After all, no matter how many times you run an executable or iterate over a loop the ones don’t wear down to .6 or .7 and the zeros don’t start to fill in and turn into .3 or .4? The code, barring disk errors and cosmic rays, doesn’t change.

There are a few things that maintenance implies with software. Unless you’re running on an embedded system and there is no operating system you’re relying on third party code. And even if your code is perfect there are going to be changes and updates to someone else’s code you want to use. It could be to pick up new features or better performance, or it could be to close a security loophole, like the log4j issue. So there’s always a reason for maintenance.

Even without those reasons for maintenance, you probably want to do something to the code. Add a feature. Respond to new business requirements. Reduce support burden. All of those things are maintenance. And sometimes, to enable that kind of maintenance, you need to do internal work. To keep the external software quality (ESQ) high, you need to work on the internal software quality (see ISQ vs ESQ).

That’s where scheduled maintenance comes in. Doing the extra work so you can do the required work. The unseen work that lets you keep your velocity up. The unseen work that lets you respond to changes in the environment quickly. The unseen work that lets you add value.

Which means there is value in that unseen work. So don’t skimp on it.

Error Based Development

I’ve often (usually? almost always?) found it easier to write code than it is to debug it. Even code I recently wrote. If nothing else, when I’m writing code I have all the context in my head and I know how all of the API calls are going to respond. Even if I’m wrong, I know what I’m expecting and I write the code accordingly. Of course, that’s not always the case, which leads to debugging.

Some days the debugging is easy. I can look at the incorrect result, error message, or stack trace and know what I need to do to fix the problem. Other times there’s enough info to point me at a section of the code and I can trace it through and find the issue. I can try different inputs and write special debugging code to help me understand what’s going on.

Other days though it’s a struggle. The error messages don’t help. Code inspection gets you nowhere. Debug code doesn’t even help. No matter what you do the error keeps happening and you get no extra information. This happens most often with 3rd party libraries and web calls because all you’ve got is the documentation. So you try changing something as a way to map the boundaries of the problem.

And nothing changes. Google searches. Stack overflow. The expert on the team. Nothing helps. So you go back to first principles and build a walking skeleton that has just enough meat on the bones to work. Then you keep adding to it until it breaks the way the thing your debugging breaks. Or conversely, you start taking things out of the broken thing until something changes.

Then you can really start debugging. You’re back in control of the system. Or at least having some kind of influence over it. Because without being able to influence the system you can’t characterize the problem or drive to a solution.

There have been countless times this has happened to me. I’ve worked for hours trying to vary the inputs subtly so that I can understand how the system is actually responding. Trying to get to the point where the error is in code I have influence over. So that I can fix it.

But as annoying as that is, it reminds me how much better things are now. Where I can click a button or run a single command and the system makes sure that I’m exercising the code that I’m working on. Not like things used to be. Before Makefiles having nothing happen was common. To actually see your change was a multi-step process. Change the code in some editor. Save the code. Compile the code. Link the code (at however many levels are needed). Run the new executable. Miss any one of those steps and nothing changes.

Sometimes I miss those days :)

The Importance Of (down) Time

Time passes. Even if nothing else changes, time passes. That’s the same for everyone and you have no control over it. What you do have control over is what you do with your time.

How you use your time has a huge impact on your impact. At one of the highest levels there’s work-life balance and how getting that wrong leads to burnout and having no impact. One level deeper on the work side is managing work in progress (WIP). Just being busy is NOT the way to have the most impact.

One way to make sure your time has impact is to use it to prepare for the future. To be learning ideas and new approaches. Taking the time to explore and add a new tool to your toolbox or be able to use your existing tools better.

Which brings us to the most tactical of levels. How you learn. Learning is different for everyone. What’s best for one person is not going be be best for another. Some like to read in silence. Some like demonstrations and examples. Others, like me, do best with hands-on experience in a group. Knowing what works for you and taking that into account is important.

One thing that seems to be important for everyone though is down time. You can’t keep stuffing knowledge into your head for 8 hours straight and expect it all to stick. Periods of intense learning/studying/training followed by periods of “idle” time so that you can process those learnings and make them stick.

I have no idea if this is actually the mechanism, but the way I think of it is that there’s an inbound queue of knowledge. As you’re learning/experiencing things get pushed onto that queue. At the other end of the queue is a process that takes those things, stores them somewhere, and associates them with everything else you already have stored. As long as the incoming rate is below the acceptance rate of the queue everything is fine. If the incoming rate is too high things get dropped on the floor, never to be seen again.

At least that things are OK until the queue fills up. When the queue is full the acceptance rate drops to the processing rate at the other end and everything falls to the floor. There are lots of things you can do at that point. You can (to a certain extent) make the queue bigger or (somewhat) turn up the processing rate. You can make the queue deeper by recording the input and then replaying it later when the queue is empty. You might even be able to slow down the incoming rate. Good teachers, knowing about the limitations, will do that for you.

The other thing you can do, especially at work, is take a break. Not just a break from learning, but a break from concentrating. Doing something that doesn’t use the same part of the brain as the thing you’re learning, but keeps the body busy. The classic example of that kind of break is thinking in shower, but that’s not practical during the work day. Which is why you’ll sometimes find me walking in circles around the office. Sometimes just listening to music, sometimes playing solitaire, sometimes just walking. It gives the processing end of the queue time to catch up and drain the queue. So you can keep learning. Which is what you wanted to be doing with your time in the first place.

Careers Pt 1 - Levels

I’ve been doing this for a while. And like the Farmers Insurance guys says, I know a thing or two because I’ve seen a thing or two. I’ve written a little about it before, but I figured it’s time to add a little more detail to how I think about things and what I’ve learned. About what levels are and aren’t, and what they’re a proxy for (hint: it’s influence, not ability).

Some background. First, this is based on what I’ve seen and experienced at small startups (you’ve never heard of them), game dev companies (Microprose), mature, large tech companies (Microsoft, Amazon), and hypergrowth startups (Uber), and mid-sized startups (Aurora) as well as discussions I’ve had with folks at other tech companies, large and small.

Second, your mileage may vary. While many companies have standardized processes, your experience is very much dependent on your direct manager and the managers 2-3 levels up. At larger companies the experiences in one area can be very different from the experiences in another part of the company.

Third, the environment now is different than it was when I started. Pandemics. Work from home. The great resignation/reshuffling. Today’s cell phones have more compute/graphics power than any single computer (or cluster) you could buy.

With all that said though, at the core, things haven’t changed that much. Your job, and what makes a difference, is the business value you provide. The business problems you solve. Not the code itself. Which means the way to look at it hasn’t changed much either.

Let’s start with some basic facts about levels

• They’re just numbers. Typically about 8 of them. They might start at 1, they might start at 59. But the important part is that they’re just numbers.
• They do
  • Set expectations
  • Usually based on some written rubric, but it might be implied (especially at smaller companies)
  • How others see you. Coworkers expect more from a senior engineer than from a new hire
  • Often defines your title.
  • Often inform compensation. Typically there’s a compensation band for each level and there is overlap
• They don’t
  • Define what you do. People at a given level can work on lots of different things.
  • Define your role. At a given level you could be a software engineer, a hardware engineer, a PM, or a manager
  • Define how you do things. Different people do things in different ways. As your level and role changes, the way you do things changes. What and how much design, implementation, coordination, problem solving, and problem identification you do are not defined by your level.
• They are (generally) given in recognition, not aspirationally. You get the level after you’ve been consistently demonstrating that you are working at that level. Not as a reward for working hard or to help you reach the level.

You’ll notice that since level doesn’t define what you do or how you do it there are people with wildly varying roles at the same level. Which means there needs to be a way to compare people at a given level. To keep things simple I’ll focus on individual contributors (IC) and managers in software engineering, but the same idea applies when comparing PMs, designers, engineers, etc.

In software engineering, breaking things down into really broad strokes, there are two major categories:

• Technical Impact
  • What things you know about
  • How much you know about them
  • Defining/Selecting Work Product
• People Impact
  • Building/Maintaining Relationships
  • Building/Growing People/Teams
  • Defining/Selecting Work Product

For your typical IC, plotting those two areas vs. Level will give you something like these two charts. What this shows is that as your level increases (career growth) the typical IC will continue to grow technically, but the people management side levels off. I’ve left off years of experience (YoE) and any units on the vertical scale on purpose. It takes as a long as it takes, regardless of YoE. This is a unitless Y axis because it’s relative, not absolute.

For your typical manager though it looks a little different. They start the same since lower levels managers are typically ICs and follow the same growth. After that they differ though, almost reversed. The technical breadth/depth stays the same, but the people side grows.

Once you’ve got those graphs it’s easy to compare them, right? Just overlay them and you know. Or not. What you end up with is a graph of diverging lines that doesn’t really help at all. Like this.

But when you think about it a little deeper, you realize that there is one thing that grows with level, regardless of your what you do or how you do it. That one thing is Scope Of Influence.

It’s Scope of Influence that grows with level and how you can compare the impact of people at a given level, regardless of role or title. As a new IC engineer, whether fresh out of school or self-taught, your scope is yourself. You mostly implement things. A little internal design, but how the thing you’re building interacts with other components of the system is defined for you. You don’t have a lot of impact on how other people do their work. As you grow and your level increases that changes. First it’s another person or two on your team working on a feature and how it will be used. Then it might be how the whole team works to solve a specific business problem. As you get to “senior” levels you’re influencing how things are done across multiple teams. At the “staff+ (IC)/Director (Mgr)” levels your influence is across organizations or business units or products, depending on how things are organized where you are. It doesn’t matter if you’re an IC or a manger.

Understanding how levels and scope of influence relate to each other is critical to deciding on your path and managing your career. But it’s just the framework for doing it. More on the deciding and doing are topics for future posts.

Faster or Slower?

Speed kills. Measure twice, cut once. Rework Avoidance Theory. We’re trained from an early age to slow down when faced with uncertainty. To be cautious. To not drive faster than we can see. And often it’s true. Especially when operating heavy equipment. Simple physics tells us that mass * velocity equals inertia. And as Newton said, an object in motion stays in motion. Changing directions or stopping means working against that inertia. So if you want to be agile and be able to change your direction easily then you need to slow down.

So what do we do in software development to make sure we don’t go too fast and make it hard to change direction? A common response is to add process. Long manual processes to ensure that we keep going in the correct direction. That we’re not wasting our time. That nothing bad happens. Cascading gates with lots of places to stop and roll back. That makes sure we’re going slow for safety. Right?

That’s one option for sure, but it’s not the only one. And in many cases, with software it’s not the best option either. Slowing down reduces inertia for sure, but it’s not the only way. Consider the other half of the equation. Reducing the velocity by 50% reduces inertia by 50%. But the same thing happens if you reduce mass. It’s a linear equation, so you can have just as much impact by changing mass.

In development the analog to mass is the size of the change. Smaller changes are less “massive”, so for a given velocity they have less inertia. They have less coupling. They have less surface area. They have less drag. They take less time. They’re easier to undo. So you can make more changes.

There’s another thing to keep in mind. When you slow down changes tend to accumulate, so the “mass” goes up. In fact, it’s not unusual for the mass to go up so much that going slower means there’s even more inertia and it’s even harder to make changes. Which is exactly the opposite of what you want.

Or, as I’ve said before, Speed is Life

Planning vs Scheduling

Q1 is done in most places, so Q2 planning is mostly done as well. Or at least what passes for planning. The list of expected (required?) work has been identified, ordered, and scheduled. Names have been assigned to each one. The “planner” now knows who’s doing what and when it will start and finish. How could anything possibly be more planned than that?

In theory, that is planning. But as they say, in theory, there’s no different between theory and practice. In practice, there is. That happens to the plan almost instantly. Someone is out for a day or two, something takes more (or less) time than expected, or some new piece of information becomes available and suddenly something that wasn’t important is now the most important thing. As soon as any of those, or a host of other possible things, happens your detailed plan, with names and dates and expectations, goes out the window.

The fact that the “plan” is invalid is obvious. What isn’t always obvious, and certainly not as well understood or accepted, is that you didn’t have a plan in the first place, so there’s no way that the plan became invalid. What you really had was a schedule, and the schedule that became invalid.

Now schedules aren’t bad. In fact, whenever you need to coordinate two or more people/teams/orgs/groups schedules are critical. They let the second party know when they can expect something from the first party. They provide a mechanism for sharing information about the current validity of those expectations and changes to them. They let you largely decouple things. They let you identify inverted dependencies and places where things won’t be ready when they’re needed.

Schedules are required for planning. The schedule is one of the inputs to planning, along with your overall goals and your priorities. Planning is the process of taking your overall goals and priorities and adjusting those schedules based on the dependencies discovered so that you end up with the thing you need when you need it. Planning talks about contingencies. Planning defines how you respond to things. Instead of a simple ordered list it’s a branching graph that winds its way to the goal. It’s reactive and responsive to the environment as you proceed. If A happens we do B. To ensure C doesn’t happen we do D. If E doesn’t happen we do F, then change A and D and switch the ordering of G and H to compensate.

So you need schedules to make plans. Unfortunately you can’t schedule everything. You need to know what the priorities and goals are. You also need to know what responses to the environment you might need so you can schedule them. But you don’t know those responses until you finish planning. And you can’t do your planning until you’ve done the scheduling. Which leads us to a dependency loop.

One really good way to break that loop is to do them at (almost) the same time. Top down **and bottom up. The goals and priorities give you a small set of things that need to be done, so schedule them bottom up. At the same time, do some sequencing and strategic planning of the those things to identify dependencies and possible environments responses top down. That gives you some new things that need to be scheduled, and the newly defined schedules give more insight into the dependencies. Iterate a few times until it starts to converge. Then stop planning and scheduling.

Start working and monitoring. As you progress you’ll figure out which of the responses you’ll need. Update the schedules with actuals. Feed the reality back into the plan. Adjust the plan. Lather. Rinse. Repeat. Because like Eisenhower said, Plans are worthless, but planning is essential

And one last thing. Consider not assigning tasks to people when you’re scheduling. Don’t ignore capacity, but putting actual names down is just one more constraint you don’t need. There’s lots more to say about that on another day.

QWAN

You’ve probably heard of the Gang of Four and their book, Design Patterns. You might even have a copy on your shelf. I know I do. There’s a lot of good stuff in there. Reusable concepts (patterns) that can be used whenever the situation calls for one of them. I’ve talked about some of them before, like the builder pattern, or the difference between adapters, facades, and decorators. They’re best practices, but as I’ve said, they’re only best if used at the right time.

One thing I haven’t talked about though, is where the idea of design patterns came from. They originally came from the world of architecture. Way back in 1977 Christopher Alexander coined the term in his book A pattern Language. The book lays out the common patterns that can be used as building blocks when creating a vibrant community. The book laid the foundation not just for the GOFs Design Patterns, it popularized the idea of a pattern language as its own concept.

Pattern languages are a way to express the fundamental building blocks in a field. Building blocks that can be combined to define, describe, and document whatever it is that you’re trying to build. The Bounded Contexts. The Ubiquitous Language. And not just define the thing, but when combined correctly, ensure that what you’ve created has that Quality Without A Name (QWAN) that makes it more than the sum of its parts. Its hard to describe, but you know it when you see it.

As the user of a piece of software, do people like to use the software? Does it simplify things? Make them frictionless? Does it align with the other things they are doing? Does it spark joy? As a developer of a piece of software, is the code easy to understand? Easy to extend? Do the internal boundaries match the external ones? Do you look at it and go “Of course that’s the way it’s done. Why would you do it any other way?” In either case, does it delight you, but never surprise you?

Christopher Alexander recently passed away, but his insights are as valid now as they ever were. So next time you’re designing something think about the pattern language you should be using. And always look for the QWAN.

Do You See What I See?

Context is a concept that comes up here a lot. Usually though, when I talk about context I’m talking about having enough context to understand what you’re doing and why. Or how the different parts of the code you’re working on fit together to provide value. But there’s a whole different kind of context. The shared kind of context. The kind of context that gets used when you’re trying to share information.

Because of course, you have your own context. The things you know. The assumptions you make. Assumptions about the state of things. Assumptions about what other people know. Assumption’s about what’s important to others. Everyone else has their own context too. With their knowledge and their assumptions. And there are some shared assumptions there too.

One of the biggest of those shared assumptions is that those contexts are about the same. That you have shared context. That the things you know are the same as the things as those you’re talking to. That the things you know is roughly the same as what the people you’re trying to communicate with and that’s roughly the same as what everyone knows. And that all you need to do is add that little bit of new knowledge and everyone will be in the same place.

In truth, the situation is a little different. What you know can be very different from what the people you’re communicating with know. If you’re on the same team, working on the same tasks you’ll share lots of specific context to the work, but your history and past experience with be different. Someone on a partner team will have some of the same context/knowledge, but not all of it. People on teams you don’t work with have less shared. People at a different company or in a different industry have even less.

Practically speaking, without ensuring everyone has the same context you’re not communicating. You might think people are agreeing, but without the shared context you don’t know if you’re agreeing about what the situation is. And if you’re not in agreement on what the situation is, how can you reach agreement on what to do about it?

One of the best ways to deal with the issue of differing contexts is storytelling. Don’t just throw out some facts and hope people hear what you hope they do. Take the time to tell a story. Start at the beginning and set the shared context. Tell the story of how you want things to look in the future. Walk them through the story of how you expect to get from where you are to where you want to be or tell the story of how you got from where you were to where you are. Then finish the story with how things have changed and how you’ve achieved your goal.

So next time you need to share information, regardless of whether it’s just information on what the situation is or what the best way to address a problem is, tell the story that makes sure you all have the same context and you’re all seeing the same thing.

Don't just take notes

I’ve got a Remarkable 2 next-gen paper tablet. I got tired of grabbing a new tablet for every meeting and having piles of notebooks with 5 or 10 used pages around my office. Since I’ve had it I’ve been using it for meetings instead of grabbing the nearest piece of paper. Since then I’ve discovered a few things.

First, I haven’t lost any notes since I started using it. I only have to keep track of one thing and it’s always with me. My desk is less cluttered and I’m wasting less paper.

Second, I’m not distracted. There are no pop-ups from Slack, email, zoom/meet/chime/teams, or document updates. There’s no browser to wander off into. No social media to watch. No emails to read/send. Just note taking.

Third, I can organize my notes better. Folders for various things like 1:1s, projects, etc. One shared/shareable space. Not just on my tablet, but online where I and others can see them. I can move things around inside my notes. If I need to go back and add something I can, I can move things around and make room for it, not just draw arrows or say the info is somewhere else.

But the most important thing I found is that having the notes with me is that I interact with them more. Prior to this I would only interact with them when I needed a bit of info that I had recently written down. If I needed it more than I few days later I either forgot I had written it down or couldn’t find the write piece of paper, then forgot about it. Which made most of them kind of useless.

Now, things are different. I see the notes and go through them. I see them in relation to other notes. I add things I remembered later and add follow-up questions. I add action items (and mark them as such) that I think of later. I add things I’ve done as follow-up. I refer to them when someone asks a question. I actually use them. Which was the point of the notes in the first place.

Now none of this (other than having them all on one tablet) is really because I’m using the Remarkable 2. That just fits my personal style of learning/remembering (writing vs typing) better. It’s really the repeated interaction with them that makes the difference.

While I’ll never encourage you to not take notes, I will encourage you to think about what you’re going to do with the notes. Think about how you’re going to get value out of them. Think about how a small change in your mechanism(s) can give you a much larger return on investment.