Book Review-The Change Masters

My journey through change management work led me to The Change Masters in an indirect way. When I mentioned that I was writing a course on change management, and I listed off several of the authors’ works I was using in the course, my colleague mentioned that, years ago, they had learned change management from The Change Masters – but it was a book I hadn’t heard of and hadn’t heard people refer to. Like it frequently happens when books arrive in my consciousness this way, there are many useful nuggets.

Published in 1983, there is already a concern about the ability for organizations to be innovative. We may have managed to conquer the assembly line and mass production, but it seems that most people have lost their ability to innovate, to try something new. This is the heart of the change that The Change Masters is focused on – how do you help people be more willing to look at things in a new way?

Efficiency and Effectiveness

Efficiency is doing things right. Effectiveness is doing the right things. It is a subtle but profound distinction. We had gotten so good at optimizing processes that we had forgotten to ask whether we were optimizing the right things. We were asking whether we were using the right tool to chop down the tree without realizing we were in the wrong forest. In an age of mergers and acquisitions, we had become slave to the quarterly earnings report and had lost our way to long term performance.

It’s certainly true that we need goals to pull us forward, and small, incremental goals can be useful. The problem is that this must come in conjunction with, not instead of, a long-term strategic perspective. With CEOs and management teams trading positions like kids playing musical chairs, there’s no reason to be concerned about the long-term performance of the organization. What matters is the next quarterly earnings report and the bonus that’s attached to the right outcomes – whether they created them or not.

Innovation

Being innovative is hard. It requires a diversity of skills, a willingness to see a new future, and a heaping of trust. If you’re expecting that your next mistake will cause you to be the first one to laid off, you’re not going to be willing to make mistakes – and being willing to make mistakes is what makes innovation possible. I’ve done a lot of research on innovation (see Innovation by Design, The Art of Innovation, Unleashing Innovation, and The Innovator’s DNA for a start). I’ve come to realize that there are interrelated factors of safety, courage, trust, and diversity of thought that are woven into the fabric of organizations that are innovative.

The Edge of Us

An interesting topic explored by Trust: Human Nature and the Reconstitution of Social Order is what happens when the locus of trust is placed in different places – in the individual, in the family, or in the country. The Evolution of Cooperation touches on this as it explores mathematical models and computer simulations for the best strategies of organisms. The funny thing is that the larger we define the boundaries of “us” – and the fewer people we’re willing to put into the category of “them” – the greater our chances of success – and even survival. Jonathan Haidt in The Righteous Mind makes the point that we didn’t become the dominant biomass on the planet because of our fur protecting us from the elements, our keen eyesight, or even our talons and claws. We became the dominant biomass on the planet because of our ability to work together. The trick is how large do we draw the circle of us and how many people fit in it? Robin Dunbar pegs the number at around 150 people, with some people having more and some having less. (See High Orbit for more.) The larger we draw the edge of us, the greater the opportunity for diversity (see The Difference for more on why we need diversity) and the greater our opportunities for creativity. (See Creative Confidence for more.)

If we want to reach forward into innovation, we need to learn how to draw the boundaries of us beyond our department, our division, and maybe even beyond our own organization.

Change and the Loss of Control

Hidden somewhere deep underneath the obvious reasons why we avoid change, there lies another more honest reason. Of course, when there are changes, there are fears that the change may mean something worse than our current situation; but there’s a deeper fear that we may not be in control as much as we think we are. Someone externally changing things on us is a painful reminder that we’re not in control as much as we might like to believe we are. In Compelled to Control, J. Keith Miller points out that everyone wants to control – but no one wants to be controlled.

The change masters, those who are the best at helping organizations and individuals change, can convince someone that the change was their idea, like Tom Sawyer convincing the other boys to whitewash the fence for him. Mark Twain, and Tom Sawyer by extension, was ahead of his time. It would take decades for people to explore intrinsic motivation and how to get others to do things for you. (See Influence, Pre-Suasion, The Hidden Persuaders, and Influencer.)

15 Minutes Ahead and To the Victor Go the Spoils

Woody Allen was worried about an advanced civilization that was 15 minutes ahead of us. They’d always be first in line at the movies. They’d get the best parking spots, and they’d never be late for a meeting. He was concerned that it didn’t take a big lead to make a big difference. Even a small lead would do.

This is particularly true if the world operates under the model of “To the victor goes the spoils.” That is, the person who wins the first round gets more of the benefits than the loser. The winner therefore has an even bigger advantage the next time. Over time a small advantage can become a big advantage. It’s how Steven Kotler explains the extraordinary feats that some people are capable of in The Rise of Superman.

Immobilizing Managers

Nothing immobilizes a manager – or anyone in mankind for that matter – faster than uncertainty and insecurity. When trust is vacant, and the outcomes are uncertain, people – not just managers – hunker down and brace themselves for whatever is coming – whether it make sense to do so or not. When faced with uncertainty, the most likely response is nothing. The response is that we should “hold tight,” “stand pat,” or “seek wise council.” In short, do anything that looks like something but is a statement about intentionally doing nothing.

Change masters work hard to increase trust and instill in others a sense of safety. The sense of safety must go beyond the challenges the organization is facing. You can’t keep moving forward without hope and the sense that it will be okay. You can’t keep trust and safety in a storm of ambiguity and uncertainty.

With the Flick of the Tongue

Within a few years of starting in business, I was working for the CEO of a manufacturing company doing special projects. He had pulled me away from my IT position and asked me to “just do stuff.” It was a variety of things, from pairing me up with a sales guy to relieve some excess inventory to helping change the efficiency of the direct import operations.

One of the things he said was that he had to be very careful about how quickly he changed direction. He described himself as the big gear at the center of a very large machine. If he turned too quickly, it would send all the little gears spinning. He was very wise and knew that a simple comment he might make, a simple flick of the tongue, could send people scrambling. Sometimes that could be in the right direction, but at the wrong speed and more critically, it might send people off in the wrong direction.

No Surprises

The real change masters know that people don’t like surprises – other than a few people who like surprise birthday parties. That’s why effective project and change managers are good at making sure that people arrive at a meeting, and there are no surprises. If they’re in the hot seat over something they did or didn’t do, they know it’s going to happen before they get there.

It helps people feel safe knowing that they won’t be ambushed in a meeting, and that safety plays out in a greater willingness to take risks.

Specific Requests Get Specific Action

One of the characteristics of great leaders – in change or any other discipline – is their ability to reach clarity. They’re able to cut through the fog of the conversation and find the root of the problem, the key missing ingredient, and identify the key next action. Change masters are therefore good at making the specific request that they need, not some vaguely-worded plea for help.

Though this can be perceived as some as overly direct, pushy, or even rude, clarity in the request creates action. General pleas for help are generally ignored. Specific requests may be denied, but they’re more frequently accepted.

Tolerance for Uncertainty, Not Just Any Old Risk

Success in change isn’t the same as a high tolerance for risk. Adventurous people may be willing to take risks, both personally and professionally, that no one else will take. However, that doesn’t necessarily mean they’ll be in the right position to help enable change. Bridges in Managing Transitions explains that change means navigating a neutral zone of uncertainty – and that isn’t easy.

When looking to build the capacity for change, the key is not the development of risk tolerance in general but is instead about the development of an acceptance for ambiguity – the kind of ambiguity that is the natural result of change.

Touching Them Personally

Many organizations believe that involving employees in every decision or every important decision is a way to help them feel more connected and more loyal to the organization. However, this can just as easily motivate them to leave. Most employees see the kinds of wicked problems that leadership faces as “above my paygrade.” What they are, however, interested in are two things. First, their perspective on the big issues should be heard. Second, in the kinds of day-to-day annoyances that they face, they want to be able to share their input, expertise, and solutions.

Strangely, we’re less concerned about the big picture issues than we are the tiny annoyances. We’re more concerned with the daily mosquito bites than the potential bear in the woods. If you want folks to rally around their cause, sometimes it’s necessary to make the cause tiny and impactful to them personally.

Local Experiments

Carl Rogers used to say that people are experts in themselves. (See Motivational Interviewing and A Way of Being.) If we want to be effective, one way of doing that is to tap into that expertise and allow individuals to share their expertise on their life and their world through the development of small-scale experiments that appear to work for them.

While not every experiment will work, that is not the point. The point is that the people with the most expertise in the situation are trying to make it better.

Plans as Symbols

Eisenhower said that no plan survives engagement with the enemy. If that’s the case, then why plan at all? The answer is that the planning process has value – even if the plan doesn’t. In organizations, the plans send a strong signal to the organization about what’s important, the way the organization is approaching the challenges, and what they expect or hope to do.

While the plan itself may be useless, the planning process has inherent value.

Understanding the Pig Roast

Relayed in The Change Masters is a story of how a young boy set fire to a house in which a pig is trapped. After the fire is extinguished, the villagers discover the now roasted pig and eat it. They love the delicacy. They then proceed to trap a pig in a house and set it on fire every time they want to eat roast pig.

In many organizations, we do this. Because we don’t know what about our actions created the result we want, we keep doing all of the actions with sometimes outrageous costs. The lack of understanding of what things caused the result means that we can’t get to the root of what we need to do. Therefore, we sometimes burn down houses for the sake of roast pig – instead of putting the pig on a fire.

While no one book can convert you from a change neophyte to a change master, The Change Masters isn’t a bad start.

Techsplaining Episode 57: Identifying and Coping with Burnout with Rob Bogue

Recently, I got with the Techsplaining crew and talked about combating burnout. With COVID-19, many of us have been stuck at home and having a hard time coping. It can be hard to tell whether the feelings of exhaustion, cynicism, and inefficacy are a temporary result of the pandemic or if they’re signs of a more serious burnout problem. I break it down for you and talk about how to both identify burnout and recover from it in this day and age.

You can listen to the full podcast here: https://www.techsplaining.net/2020/08/14/episode-57-identifying-and-coping-with-burnout-with-rob-bogue/

Technology Advice Podcast: How Understanding Change Makes You a Better Marketer

I recently went on the Technology Advice podcast and talked with Mike Pastore about change management and marketing. In it, I talk about how understanding change helps you understand your clients. Change can lead to stress and fear, and while much of marketing is based on stress and fear, it’s important to realize why fear-based marketing won’t always work. I also discuss how managers can help their employees feel supported enough to adopt a change – as long as there is sufficient trust to avoid too much friction stopping the change.

You can hear about these topics and more by listening to the full podcast here: https://technologyadvice.com/blog/marketing/podcast-how-understanding-change-management-makes-you-a-better-marketer/

Western Governors University, Bachelor of Computer Science Graduate

I graduated. I never expected to go back and get a second Bachelor of Computer Science degree, but I did. The reasoning is a bit strange – even by my standards – and the path is even stranger. Those who know me would never question or wonder whether I had a bachelor’s degree or not. Dozens of books written, editor on a hundred more, and countless articles and presentations. Why would anyone question whether I had a degree or not?

My First Bachelor’s Degree

I was sitting on the leather couch next to a mentor and friend of mine in front of a fire at his house when he asked, “Why haven’t you bought one of those degrees yet?” “What?” I stammered. He was a lifelong educator teaching high school and college and eventually ending up on the school board. I couldn’t understand what he was saying. It turns out he was paying me one of the biggest complements of my life.

He, more than most, knew I was a lifelong learner. I hungered for it. I was editing about 16,000 pages a year at that point, and I was always discovering something new. But he actually asked that question. He explained that I already knew the things I needed to know, I just didn’t have the paper.

It wasn’t too long after that when an email crossed my desk. A degree for life experience. It was a few hundred dollars, and you had to produce documentation of your experience – which was easy to do, since I kept records of my work on book projects and Amazon was just starting out so people could verify the books that I had worked on.

For my money, I got a very official looking package from Concordia University. It came with grades, transcripts, etc. Accredited in one country, operated in a second, with web servers in a third. It was a paper mill diploma factory, and everyone knew it, but it would pass any employment screen test for a bachelor’s degree.

Why I Didn’t Go to College

Backing up the bus for a bit, one might ask the important question of how I found myself in a position where I didn’t have a college degree already. For that, you must look past the good grades in high school, the decent scores on the ACT, and the acceptance to Purdue with honors. The short version was money. Yea, FAFSA was a thing even back then, so in theory, I should have been able to get aid and student loans to help pay for it.

The problem was that if a parent was uncooperative, if they refused to provide their tax return information, well, you couldn’t fill out the forms, and you couldn’t get the aid you needed to make it work. I tried putting together budgets but none of them worked. In the end, I resigned myself to the idea that I’d settle for night school at IUPUI while I worked. It wasn’t ideal, but I could do half time at night and work full time and the math would work out.

I had taken as many as ten credit hours at the community college while going to high school and working 20 hours a week. I knew I could find a way to make night school work, because I was willing to work hard.

The Siren Song of Technical Editing

Mike Groh was a quirky character when I met him. He was married to the marketing director for the company I was working at. I was at their house to help them get connected to the corporate email system. Back then, it was modems and store and forward email, and it was my job to make sure that the directors were successful. Mike was working for New Riders Publishing – then an imprint of McMillian and, ultimately, Pearson.

He asked me if I would be interested in technical editing books. I explained that grammar and I weren’t on the best of terms; we had a strained relationship. Then he explained that they needed someone to read the material and make sure it worked. It was an ideal job. I got paid to learn.

I had been grousing about having to take assessments at IUPUI even though I had passed the AP tests and had college credits. It was a part of the procedure, and I was caught up in the machine. It wasn’t long before Mike came through with some work. I started technical editing with Inside Paradox and Inside Microsoft Access, the two competing database technologies of the day. I loved it. It made money instead of consuming it.

I resolved to defer college until the technical editing thing had run its course and I had saved some money.

I Got Hooked

Like an addict, I picked up more technical editing. I was, for several years, doing about 16,000 pages a year after my full-time job. It was fun. I loved learning and only occasionally got too overwhelmed. I was sometimes offered development editing opportunities, which paid better and really amounted to what I was doing plus talking about how to explain the concepts better. I even got a few authoring opportunities.

Authoring wasn’t my favorite thing. It took a long time and the rewards were less than editing. However, it felt like it was the thing to do. Before I knew it, I lifted my head, and years had gone by. Eventually I realized that I’d never go back to traditional college. I’d be bored to tears. That’s when the conversation came and when I bought the degree.

The Master’s Degree Trigger

I didn’t find Western Governors University (WGU) because I wanted to get a bachelor’s degree – at least, not directly. I started out investigating a master’s degree in healthcare administration. It’s a place that I’m passionate about. I want to make healthcare better. I figured the bachelor’s degree I had worked well enough for background checks. It should work as a prerequisite degree for a masters.

I was wrong. In the years since I had gotten it, almost every school had gone electronic. Now, it was easy for one school to validate the credentials of another – and there was a master database of universities that were accredited – by accrediting bodies that mattered.

I wanted to move on the healthcare administration journey, but that meant going backwards to get the bachelor’s degree.

Hits and Misses

I decided to find a solution that would be the easiest for me to do. That was computer science. My first semester at WGU, I completed 60 credits. WGU uses an “all you can eat” plan for your tuition. You pay a fixed amount per six months no matter how many classes you take. I tested out of a lot. I could have even tested out of more, but I wanted to save a few easy classes for later semesters.

It’s been a year and a half since then. During that time Terri (my wife) got very sick for a while, and it was all I could do to keep the wheels on the cart. Juggling kids, the business, and WGU was more than I could do. I met my requirement to do at least 12 credit hours and kept everything afloat through a semester where Terri was ill for three of the six months.

The last nine months of my journey, I’ve been only working on my capstone. Most of that has honestly been a waiting game. I decided that I wanted to prove that I can improve environmental services workers’ training so they’ll clean better using augmented reality, and Microsoft’s HoloLens 2 was announced but seriously unavailable.

For reference, I don’t think that I do things the way others do. While I was getting my degree, Terri and I wrote a book together (Extinguish Burnout), and I created a comprehensive course on change management (Confident Change Management). I was busy. I’m looking forward to the opportunity that things can slow down a bit, and it can resume just normal crazy.

My capstone completion would mark 2 years since I started. Great time for college as a part-time thing – but easily a year longer than it needed to be due to delays and capacity problems.

The Program Itself

Having three children currently in traditional colleges and a wife with a master’s degree, I have an interesting perspective on the process. WGU taught me when that’s what I needed. (Calculus isn’t necessarily easy.) It also allowed me to test out of those things I already knew. For the most part, it stripped the stupidity from the college experience, and it dropped all the participation awards.

I’m comfortable saying that if I needed to learn a topic, it taught it to me. It seems on par with the education that the children are getting – with a lower price tag and a much better schedule.

I would have never survived going to classes each week for 15 weeks. As it was, I shook the cages at WGU rather hard for the handful of courses that had rough edges. (I was bound and determined to leave the program better off than I found it – even if I had to explain instructional design to people with master’s degrees in instructional design.)

All in all, I’d recommend it. I’d recommend it for adults who want to go back for a degree – and even for high-performing students who want to get their basic degrees out of the way so they can get to what they really love.

What’s Next

As for what’s next for me, I don’t know. I may go back and get the master’s degree in healthcare administration. However, I won’t start that right away. I am also considering a master’s degree in psychology, but I’d do that more for me than for than any earning potential.

Decomposing the Unity UI Automatic Layout System including Vertical, Horizontal, and Grid Layout Groups

If you’ve ever tried to get the automatic layout system to work and it just didn’t, you’re not alone. What should have been a simple exercises in dropping three Text Mesh Pro components into a Canvas with a Vertical Layout Group caused me to end up spelunking through the layout system to find what it was trying to do, how it was doing it, and finding a way to resolve the problems. This is the journal of my journey – with a bit of reorganizing to make it more straightforward.

RectTransform and ILayoutElement

Unlike a Transform, which locates a GameObject in 3D space without a size, the RectTransform includes an inherent size in 2D space – there’s a width and height. If you’re trying to lay out items vertically, you should just be able to look at the height of RectTransform, add some spacing, and stack them. However, not so fast: the size of an element isn’t fixed. Some elements can shrink if necessary and some can grow if there’s more space available.

In Unity, an element has a minimum size, a preferred (ideal) size, and a flexible (maximum) size. However, you can’t infer all of this from RectTransform, so it needs a component that implements ILayoutElement. (See Object Hierarchy and Scripts in Unity for more on how GameObjects in Unity are comprised of components if this isn’t clear.)

ILayoutElement specifies the six float properties that you’d expect, with three values across two dimensions (minWidth, preferredWidth, flexibleWidth, minHeight, preferredHeight, and flexibleHeight). In addition, it specifies a layoutPriority integer and two methods (CalculateLayoutInputHorizontal and CalculateLayoutInputVertical). The layoutPriority allows multiple components that implement ILayoutElement to be attached to a single game object, and the component with the highest layoutPriority value will control the settings. An ILayoutElement conveys that it doesn’t want to specify a value by setting the value to -1.0f. This allows some flexibility for different ILayoutElements to set different end values.

The two methods (CalculateLayoutInputHorizontal and CalculateLayoutInputVertical) are methods that a consumer of the interface is supposed to call prior to using the horizontal or vertical variables (respectively). This gives the component implementing ILayoutElement a chance to make sure that the values are up to date.

ILayoutController and ILayoutGroup

If you have a set of objects with the appropriate size values from ILayoutElement, it should be possible to arrange them on a 2D canvas. That’s what the ILayoutController interface does. It contains two methods (SetLayoutHorizontal and SetLayoutVertical) that a consumer can call to cause the layout controller to arrange its children on the canvas. There’s a different interface, ILayoutGroup, that the out-of-the-box layout components implement – but ILayoutGroup is a direct descendant of ILayoutController, and it doesn’t specify any additional properties, fields, or methods. In short, they’re functionally equivalent. It’s probably best to implement the ILayoutGroup interface, because that’s the interface most components expect to find.

This leaves the question about how these interfaces are used and how they’re called.

VerticalLayoutGroup, HorizontalLayoutGroup, HorizontalOrVerticalLayoutGroup, and LayoutGroup

The implementation of ILayoutGroup is, as might be expected, LayoutGroup – however, it’s an abstract class. In other words, you can’t use it directly, but it’s supposed to contain some base implementations that are helpful to its children. What’s interesting about LayoutGroup is the objects it derives from and the additional interface it supports.

Most scripts in Unity derive from MonoBehavior. This provides the baseline functionality that scripts need. However, LayoutGroup derives from UIBehaviour. This is a subclass of MonoBehavior and importantly adds additional events: OnCanvasGroupChanged(), OnCanvasHierarchyChanged(), OnDidApplyAnimationProperties(), and OnRectTransformDimensionsChange(). These events, plus the OnTransformChildrenChanged() method from MonoBehavior, are signals to try to lay out the children again, because there’s been a change that may be important.

As an aside, LayoutChange doesn’t implement OnCanvasHierarchyChanged() or OnCanvasGroupChanged() for some unknown reason, though it seems as if those events should trigger the layout to be recalculated.

The layouts that we use directly, Vertical Layout Group and Horizontal Layout Group, don’t derive from LayoutGroup directly – though Grid Layout Group does. Instead, Vertical Layout Group and Horizontal Layout Group derive from a class, HorizontalOrVerticalLayoutGroup, which in turn derives from LayoutGroup. This is a good use of reusability, as the only real difference between vertical and horizontal grouping is the axis. As a result, HorizontalOrVerticalLayoutGroup can do the heavy lifting, with both Vertical and Horizontal Layout Groups being a thin shim above it to provide specific user interface and parameters.

The Other Classes: ILayoutSelfController and ILayoutIgnorer

All of the interfaces for layout are in the same ILayoutElement – so you won’t find files for the interfaces like ILayoutGroup and ILayoutController. In this same file, there are two additional interfaces that are important for the way that things are laid out on the canvas. The first is ILayoutSelfController, which as you might expect is a way of saying to the parents of the GameObject that the item controls its own layout.

The prototypical class for this is ContentSizeFitter, which sizes itself based on the content that it contains. This allows the element to be sized to the minimum or preferred sizes – or it can be set to allow unconstrained growth. This class doesn’t position the content, but it can set its size.

ILayoutIgnorer is also, as you might expect, a way to tell the ILayoutGroup to ignore the component when doing layouts. This might be useful if you need something to stay in its position while the rest of the children of the GameObject are rearranged. The interface consists of a single Boolean member, ignoreLayout, that when set to true causes the item to be ignored for layout.

These interfaces are interesting, because there’s the very real potential to have a conflict between two scripts when an ILayoutSelfController is inside of an object with an ILayoutGroup implementation. In these cases, who wins?

Layout Conflicts and Instability

I was creating a canvas with a set of Text Mesh Pro objects on it. Each one had a different part of the overall message, and they needed to be vertically stacked. I thought this would be easy enough. I’d simply attach a Vertical Layout Group to the canvas that the Text Mesh Pro objects were on. I quickly discovered that this didn’t work. The elements didn’t line up correctly. Then I discovered I could add Content Size Fitter on the Text Mesh Pro components. They’d size themselves so the Vertical Layout Group would have the sizing function unchecked, so it would just do positioning. It looked like it worked – sometimes.

Other times, the objects would be stacked on top of one another. I couldn’t literally confirm the behavior, but my suspicion is that I ran into an order of operation problem. When ContentSizeFitter runs first, the sizes are set correctly when Vertical Layout Group comes along, and everything is good. When the order of operations is reversed, well, it’s not so good.

The solution to the problem is a new custom script, which implements both ILayoutElement and ILayoutGroup.

A Preferred Sizer

The objective was to get something that had the behavior of Content Size Fitter where it would expand to the size of the content but at the same time not prevent the Vertical Layout Group from working. Initially, the solution was to derive from ContentSizeFitter and implement the ILayoutElement that it doesn’t implement, but this proved to be challenging. The ContentSizeFitter implements a custom user interface and it didn’t feel worth it to create a brand-new custom user interface for my class. So, I violated a cardinal rule and copied some code from ContentSizeFitter into my new PreferredSizer. I felt justified in this decision, because the real heavy lifting was still being done by the LayoutUtility class that ContentSizeFitter and the various ILayoutGroup implementations still use.

The key implementation pieces were to implement the three width and three height (min, preferred, flexible) to return the value from the RectTransform’s rectangle – if it was present. If it didn’t have a value, it set it to -1.0f – the value that specifies that the value should be ignored. I then took the two methods from ILayoutElement that the consumer is supposed to call before using those values and looped those into the two methods that are called to get the right values from ILayoutSelfController.

The net effect is that, when the parent tries to get the preferred values, it does the internal work to size itself.

Getting Dirty

The last bit that must be addressed is how to inform the rest of the Unity UI system that it’s necessary to rebuild things. That’s done with a bit of a two-step process. There are numerous events that fire and can be captured by the component. These all trigger the need for the PreferredSize to recalculate. The events listed above are all received with methods that simply call SetDirty() to mark the GameObject as needing to be laid out again.

If the GameObject is active (ActiveInHierarchy), SetDirty() calls LayoutRebuilder.MarkLayoutForRebuild() with its RectTransform. LayoutRebuilder is used to signal to the layout system that the component needs to be recalculated, and CanvasUpdatingRegistry can be used to tell if an update is already in progress. Calling MarkLayoutForRebuild() causes your update methods to be called at the appropriate time. It’s the use of these other methods to inform Unity that the user interface needs redrawn that keeps the updates out of the Update() method and improves performance.

LayoutElement

The last bit of the puzzle, which may not be necessary, is to add an additional LayoutElement to the game object and set its Layout Priority higher, so that any values that I want to pin can be set explicitly. The net effect is I have a script that leverages the way that the UI system is intended to operate to size the component. Because of the nature of the ILayoutElement design, I can override that with fixed values.

Book Review-READY, Set, Change!: Simplify and Accelerate Organizational Change

What surprises me the most about the world of change management is how there can continue to be new things that I learn about it. Sometimes, the things I learn are closer to me than I could have ever realized. That’s the case with April Callis-Birchmeier’s book, READY, Set, Change!: Simplify and Accelerate Organizational Change. The proximity I’m referring to here is both geographical and relational. April’s in Michigan – the next state over from my home in Indiana. Relationally, the person she used to help publish her book is someone who I see several times a year at networking events. It’s truly a small world.

Models

There are no shortage of models when it comes to change. April introduces another model – the READY model:

  • R: Relevant and relatable messaging about the change
  • E: Engage Leaders as sponsors and actively promote the change
  • A: Advance
    communication to ensure messaging is received and advocating for stakeholders
  • D: Develop, support, and train on process and technology
  • Y: Reinforce WHY and reduce resistance to adoption

This model definitely aligns with other models. Prosci’s ADKAR model (see Successful Technology Change and ADKAR and Change Management), Kotter’s 8-Step model (see Leading Change and The Heart of Change), Stages of Change (see Motivational Interviewing), and Bridges’ Transitions model (see
Managing Transitions
). It also aligns with Simon Sinek’s work in Start with Why.

More broadly, it connects with The Psychology of Hope by emphasizing the need for support and training. (See Job Aids and Performance Support for ideas on support and Efficiency in Learning, The Adult Learner, and The Art of Explanation for more on training.) In not so short, it’s sound advice for people who are looking to make change effective in their organization. So, while it’s another model to consider, it is well founded.

Setting for Success

In Collaborative Intelligence, Richard Hackman asserts that as much as 60 percent of the probability of a team’s success is based on what happens before they come together. Here, April encourages the proper preparation in the change process to lead to better chances for success. There are, of course, no guarantees, but the more work that can be done ahead of time to prepare the organization for the change that’s coming, the more likely it is they’ll be able to accept it and the initiative will be successful.

Readiness is an Emotional Choice

There is no magic formula for helping people be ready for the change. Readiness is, in fact, a personal choice. It’s a choice about how capable you feel of coping with the transition (to use Bridges’ words). This, too, is supported by evidence. Richard Lazarus, in Emotion and Adaptation, explains that our emotions are formed based on a stressor (stimulus) and our assessment of that stimulus. Individually, we can become more ready for change through developing our courage (see Find Your Courage) and our waypower – that is, our understanding of how we’ll make the change (see The Psychology of Hope).

Technology, Training, and Barriers

Demand explains that small barriers make a big difference. While it may not seem like much, sometimes the inability to find where to start can stop people from starting at all. Instead of displaying tenacity, persistence, and grit, people give up all too easily. (See Grit and Willpower for more.) Speaking as a technologist, some problems are hard to solve – and as a change specialist, some are harder to solve if you make them people problems.

There’s a tendency – particularly at the last minute – to make gaps in the technical solution a training problem. That may, or may not, be the right answer. The truth is that all gaps should be assessed from the perspective of their capacity or propensity to derail the change initiatives success. Sometimes, it’s better to delay a little, get the technology tighter, and ultimately be ahead from an adoption perspective.

An Ounce of Prevention

An ounce of prevention is often worth a pound of cure. In change management, the preparation you do can reduce the amount of time that your success will take. Reading READY, Set, Change! may be a good start to that preparation.

Book Review-How to Be a Change Superhero: The Business Toolkit to Help You to ‘Do’ Change Better

There’s the moment right after you realize that you’ve been assigned to your first change project when panic sets in and you begin to wonder How to be a Change Superhero. Whether the thought crosses your mind early in the process or late doesn’t matter. What matters is that moment of panic when you realize that you don’t have the tools you need to accomplish the change you’re being asked to move forward in the organization. How to be a Change Superhero: The Business Toolkit to Help You to ‘Do’ Change Better is all about helping you cross the chasm between your current self and the hero that exists inside of you.

Joseph Campbell wrote The Hero with a Thousand Faces and developed what he believed to be a universal story arc that has become known as Campbell’s Hero’s Journey. The journey always starts with a limited awareness of the current situation and proceeds through a period of self-denial and self-doubt before the hero emerges. Everyone wants the hero to emerge.

The Change Equation

Richard Beckhard and Reuben Harris developed a change equation that is C=A*B*D>X, where C is the degree of change, A is the level of dissatisfaction with the status quo, B is the desirability of the proposed change, D is the practicality of the change and X is the cost of change. Said more simply, change only happens when the pain of changing is less than the pain of staying the same. In principle, I agree with the formula, though I’m careful about the multiplicative aspect of the terms. I’m not completely convinced that they’re mutually exclusive or that the effect is as dramatic as the multiplication might suggest.

Everett Rogers expressed it differently. In Diffusion of Innovations, he explained that there are five factors that influenced the rate of adoption of an innovation (the rate of change): observability, trialability, simplicity (lack of complexity), relative advantage, and compatibility. In Rogers’ model, the lack of any of these discourages change.

Against Our Will

One of the most powerful realizations in change is that you’ll likely not succeed if your approach is to get people to do things against their will. Commanding people to do something just doesn’t work as well as we would like it to. People don’t appreciate the idea that they have no choice, that it’s not their desire to do it but they must. This builds resentment, and resentment results in friction everywhere. Not only will the specific thing that’s being commanded face resistance, but so, too, will most things that you ask the person to do – even things they do want to do. The resentment around one area of their work world will bleed into other areas as well.

You Can’t Fake Sincerity

If you want to care for the people that you’re asking to make change, you’ll have to be sincere. It’s not possible – in a sustained way – to pretend to be sincere about your concern for others but not really be concerned. Somewhere, somehow, it will eventually leak out, and the resulting backlash will generally make people not trust you any longer. So, while in the short-term, faking sincerity might be possible, it’s a bad idea, and in the long term, it’s not possible at all.

Becoming a Superhero

If you want to become a change superhero in your organization, maybe read How to Be a Change Superhero.

By the way, Lucinda Carney has a toolkit related to the book available if you’d prefer to start with that.

Object Hierarchy and Scripts in Unity

If you’re a traditional developer, Unity is more than a bit odd. The constructs, for the most part, make sense, but they require that you contort your thinking a bit. In this post, I’m going to walk through object hierarchy, scripting, and reuse.

Game Objects

Everything in Unity is built up from the concept of a game object. A game object is a connection for components. Every game object will have either a Transform or a Rect Transform component associated with it. 3D objects have a Transform – which is a 3D transformation containing the location, rotation, and scale, along X, Y, and Z dimensions. 2D objects have Rect Transform components, which are designed to work with 2D objects even if they exist in a 3D space. Game objects with a Transform don’t fundamentally have a size. Their size is driven by the other components that are attached to the game object.

Game objects can be organized in a hierarchy. This is useful when you want the objects to operate as a unit, as we’ll see as we build out the rotator script and demonstrate its use to create a cluster of directional lights. However, for performance reasons, deep nesting of game objects is discouraged. Largely, this is because some operations are recursive, and a large number of recursive operations can drop the frame rate of the solution unacceptably low. (Below about 60 frames per second.)

Frame of Reference

In the post Creating A Spinning Cube with Unity and MRTK, I created a single object – called Nexus – which had child objects of lights. To Nexus, we attached a rotation script and rotated Nexus. This caused all the lights associated with Nexus to rotate and move. We were able to set the context of the lights local to Nexus, and whatever Nexus did, the light objects would do as well.

This illustrates why we need to be careful with object hierarchy inside of Unity. When we do one operation, we’re impacting seven objects inside the hierarchy. The greater the depth of the hierarchy and the more objects, the more things need to be manipulated – or at least checked – for a single operation.

Scripts and Game Objects

In Unity, scripts are C# code that is associated with a game object. Placing a script in the project does nothing until it’s connected to an instance of a game object. Game objects themselves can be almost anything – including nothing but a container with a Transform component, like the Nexus game object. When we added the script as a component of the game object, we connected the script and told Unity to instantiate the class and connect it to the game object that we added it to.

Including public properties in the script allowed us to set those properties in the editor and ultimately have one script act on multiple objects in different ways. Unity automatically tooled our Camel case names and added spaces before the capital letters to make it more readable. It also provided an editor for the complex Vector3 object. This makes it easy to create scripts that are reusable across objects and for different purposes.

HR Uprising Episode 66: Avoiding Burnout – Masterclass

A week ago, I joined Lucinda Carney on the HR Uprising Podcast to give a special masterclass on burnout – and how you can avoid it. In it, I discuss ways to identify the root causes of burnout. I talk about what our personal agency is in the context of burnout and what fills or drains our personal agency bathtub. I also review the two components of stress (the stressor itself and our assessment of the stressor) and strategies that can help you avoid burnout.

You can listen to the full podcast here: https://hruprising.com/avoiding-burnout-masterclass-with-robert-bogue/

Creating the Spinning Cube Program with Unity and MRTK

In this post, I’m going to walk through the creation of a spinning cube program in Unity. For this demo, we’ll build it with the Mixed Reality Tool Kit (MRTK) and set it up so that you could deploy it to a HoloLens 2. A spinning cube is sort of the 3D equivalent of “Hello World.” So, it’s a good starting point for developing with Unity and using MRTK.

I’m going to use this as an opportunity to explain script reuse and how you can use the same script with parameters with multiple objects. I’m also going to use this as an opportunity to explain basic game object hierarchy and how you can rotate a parent object to cause all the child objects to rotate as well. Finally, we’ll use this project to show off the MRTK orbital component that will allow us to keep objects in the center of view.

To make this project work, we’re going to create one cube object, an empty game object, six directional lights, and one rotator script. We’re going to use the lights to change the appearance of our cube as it spins. The standard material for the cube will reflect the light if we change the colors. By using the orbital component in MRTK, we’ll give the user a way to inspect the object from different angles, even while things are rotating.

Getting the Project Ready

Rather than replicating the steps necessary to create a new project and configure it with MRTK and set it set to deploy to the HoloLens 2, I’m going to refer you to the first 16 steps in the post Building a Unity Project with Speech Recognition using MRTK for a HoloLens 2. The only change we’ll make is that we’ll name the project SpinningCube, since that’s what we’re doing.

Adding the Cube and Lights

[Note: We’ve intentionally continued the numbering throughout the entire post so that we can refer to unique steps in the post.]

Let’s get started by adding our cube and the lights.

  1. Click the GameObject menu and click the Create Empty option.

  2. Right-click on the GameObject in the menu, select the Rename option, then type a new name called Nexus.

  3. Click and hold the Directional Light object and drag it into (under) the Nexus object.

  4. Right-click the Directional Light and click the Rename option in the menu. Enter the name Red Light for the light.
  5. With the Red Light selected, go to Inspector panel, and enter the position of X 0, Y 10, Z 5 and a rotation of X 90, Y 0, Z 0. This points the light to a spot 5 meters ahead of the visible camera.

  6. In the light component, double-click the Color option. In the dialog that appears, set the Red (R) to 255, Green (G) to 0, Blue (B) to 0, and make sure that Alpha (A) is set to 255.

  7. Right-click the Red Light object and select Duplicate from the menu. Repeat this process four more times until you have five lights under your Nexus object.
  8. Using the preceding steps (4-7) and following table, reconfigure the lights you duplicated under Nexus:
     

    Position

    Rotation

    Color

    Name

    X

    Y

    Z

    X

    Y

    Z

    R

    G

    B

    Blue Light 10 0 5 0 -90 0 0 0 255
    Yellow Light -10 0 5 0 90 0 255 255 0
    Purple Light 0 0 10 0 -180 0 255 0 255
    Cyan Light 0 0 0 0 0 0 0 255 255
    Green Light 0 -10 5 -90 0 0 0 255 0
  9. Create the cube by clicking GameObject, 3D Object, Cube from the menu.

You’ll notice that the cube appears to have a different color on each side. If you check the material for the cube, you’ll see that the material is a neutral color. The colors that appear on the cube are coming from the different lights we added to the scene.

Adding the Orbital Component

One way to make it possible to see what we’ve done is to add an Orbital component that comes as a part of MRTK. We can use this to keep an object (or collection of objects) in front of the camera. Let’s add the Orbital component to our cube and to our lights separately. If we weren’t going to rotate the cube separate from the lights later, we could move the cube under our Nexus object, but since we want different rotations, we’re going to keep these two objects separate.

  1. In the Hierarchy, select the object we named Nexus.

  2. In the bottom of the Inspector pane, click the Add Component button. Start typing orbital and select Orbital when it appears.
  3. Notice that Unity added a SolverHandle and set it to Head in addition to the Orbital component. The SolverHandle is necessary so Orbital knows what it’s tracking. In this case, Head is the same as the primary camera.
  4. In the Orbital component, click the Orient Type dropdown and select Unmodified. This will prevent Orbital from trying to orient the object.
  5. Also, in the Orbital component, change the Local offset’s Y value to zero and the Z value to 2– so the resulting offset is X 0, Y 0, and Z of 2.
  6. Select the Cube object in the hierarchy and repeat steps 11-14.

Testing the App

Now we can test our solution. We can press the Play button to see our cube floating in front of us in the game tab. If we move in the play mode, we can see different sides of our cube. You can right-click in the game window and move your mouse to move around in the 3D game space.

That’s a good start, but let’s create a reusable rotation script.

Adding the Rotator Script

We want to setup two different objects to rotate. First, we want to rotate the cube that we added to the scene, but second, we want to rotate the lights in the scene differently. To do that, we’re going to create a rotate script, and in the next section, we’ll attach the script to objects and configure them.

The script will define two public fields – RotationXYZ and RotationRateScale. The first will set the rotation along each axis, and the second will allow us to scale the rotation speed overall without modifying the individual variables. The only other part of this script will in Update() and will use the Transform component’s Rotate method to rotate the object.

Let’s get started.

  1. In the menu, click Assets, Create, and finally C# Script.

  2. Name the script Rotator and press Enter.
  3. Close the MRTK Project Configurator dialog, then double-click your Rotator script to launch Visual Studio.
  4. Inside the top of the class, define the two public variables:
    public Vector3 RotationXYZ = new Vector3(1.0f, 2.0f, 3.0f);
    public float RotationRateScale = 1.0f;
  5. Inside the Update method, add the following code to rotate the object:
    float totalScale = Time.deltaTime * RotationRateScale;
    Vector3 v3 = new Vector3(RotationXYZ.x * totalScale, RotationXYZ.y * totalScale, RotationXYZ.z * totalScale);
    gameObject.transform.Rotate(v3);
  6. Click the Save All button in the ribbon to save your changes to the script.

The script initializes the rotation to a default rotation of X 1, Y 2, Z 3 degrees per second and an overall scale of 1. The update method uses Time.deltaTime – a global property to determine what fraction of a second has occurred since the last call to Update(). This is the way that we can scale the degree of the rotation based on the framerate that’s happening inside of Unity. The code gets the total scaling for the rotation by multiplying our overall rate scale times deltaTime. Then a new Vector3 is created with the rotation needed, and this is applied via the transform component’s rotate method.

Attaching the Rotator Script to the Cube and the Nexus

Our rotator script is fully functional – but it’s not connected to anything. We connect it to our cube and to our Nexus object by selecting the object and dragging the script into a blank spot in the hierarchy.

  1. Start by clearing the MRTK Project configurator by clicking the X in the upper right-hand corner.
  2. Select the Cube object in the hierarchy.
  3. Drag the Rotator script into a gap between components in the inspector pane and release.
  4. Select the Nexus object and repeat step 24.
  5. In the Inspector panel, in the Rotator component, change the Rotation Rate Scale to 10.

By setting the rotation scale to 10 for the lights, you’re causing the lights and the cube to rotate at different rates, and therefore the surfaces of the cube will turn different colors as different lights start acting on them.

Viewing the Final Solution

To view the final solution, simply press the Play button and watch how the Game tab shows your cube spinning – and with the lights spinning at different rates.

You can now go to Nexus and change the rate – or the individual rotation values for each of the X, Y, and Z components to see different spinning effects. You can also navigate around the scene and the cube and lights will follow you. You can use this to look at different parts of the cube in the scene.

If you want to get the completed project, it’s available at https://github.com/rlbogue/UnityPublic/tree/master/SpinningCube