115 stories
·
1 follower

How to influence culture

1 Share
“How do you actually influence company culture?”

This is the big, hairy question I often get asked by CEOs, managers, and employees alike. The other week, I posed it at the end of my most recent piece, The Culture Cliché.

In that piece, I shared how the fundamental, core element of culture are our basic underlying assumptions. That is, the things we actually believe — but might not always say or outwardly show — are what determines our company culture.

As a result, the key to influencing culture is tapping into those basic underlying assumptions: Listening to them, responding to them, and acting according to them.

But what does that tangibly mean? Can you affect or influence others’ basic underlying assumptions, to begin with?

Yes and no.

Yes, basic underlying assumptions can be affected.

But no, they can’t be outright changed. You can’t manipulate someone else’s basic underlying assumptions. Employees are not malleable objects for leaders to shape. Each person has her own intrinsic, worthwhile desires and beliefs — and that’s not for you as a leader to try to mess with.

Instead, what you can do is to focus on creating an environment where employees can choose to shift their basic underlying assumptions in line with what feels right to them.

Let’s talk about what this practically looks like.

There are three parts to creating an environment where the kind of basic underlying assumptions you want — and ultimately, the kind of company culture you want — can come into fruition:

Personal accountability

You must model the behaviors and basic underlying assumptions you want to be true. One of the greatest shortcomings of a leader is wanting others to do something when she doesn’t practice it herself. For instance, a manager often doesn’t admit her own weaknesses, but expects employees to be upfront and forthcoming about mistakes that happen in the company. See the disconnect? Whatever basic underlying assumptions you desire to be deeply rooted in your company, you must exhibit those basic underlying assumptions yourself, first.

As the leader, you should be the living embodiment of the basic underlying assumptions you want your culture to have. You should be consciously and intentionally speaking and acting in a way that shows people, “This is important to me.”

Consistency

Your desired basic underlying assumptions won’t be made true unless they are consistent. Basic underlying assumptions are solidified when you act consistently upon them.

Say you want honesty and transparency to be a basic underlying assumptions within your company’s culture. You decide to hold an all-hands meeting every month where you cover high-level financials, company goals, accomplishments, and answer employees’ questions. Seems like it’d be an effective initiative to establish that honesty and transparency are a basic underlying assumptions within the company.

But here’s the missing piece: Is it consistent? Do you hold those all-hands meetings every month, regularly? Or has the frequency of those meetings tapered off so now it’s every 2 or 3 months…or just whenever you remember to have them.

If it’s the latter, you’re falling short of creating an environment where those basic underlying assumptions can be strengthened.

Consistency determines whether or not this tenet of your culture is fleeting, or here to stay.

Richness

Being consistent alone in how you demonstrate your basic underlying assumptions isn’t enough. You must think about the richness of how you’re communicating these basic underlying assumptions. Are you using a variety of channels, means, and mediums to show that this is something that’s important for the team to embrace and embody? Or are you just relying on one?

For example, it’s not enough to just hold the all-hands meetings and assume that’s the only way to foster honesty and transparency within the company. Consider that some people might not feel comfortable speaking up in front of the rest of the company… so you’ll want to make sure you’re also doing one-on-ones. But don’t also merely assume that a one-on-one is enough of an opportunity for someone to speak their mind. Perhaps that person doesn’t always feel comfortable directly addressing that particular manager. Make sure you provide other opportunities for your employees to speak up, be it at group lunches, coffees get-togethers, CEO office hours, or an all-company survey.

The richness of how you communicate, the varying formats and mediums, helps dictate if the basic underlying assumption is truly what it should be: foundational.

Now this is no grand formula by any means for creating the culture that you want. Shaping a company’s culture and tapping into a team’s basic underlying assumptions is more art than it is science.

But consider these three elements — personal accountability, consistency, and richness — in how you’re upholding the basic underlying assumptions you want to make more real.

Pick one, commit to it, and see progress build over time. Slowly, but surely, you’ll see the difference.

I wrote this piece as the latest chapter in our Knowledge Center. Each week, we release a new chapter on how to create an open, honest company culture. To get each chapter sent straight to your inbox, sign up below…

P.S.: Please feel free to share + give this piece 👏 so others can find it too. Thanks 😊 (And you can always say hi at @cjlew23.)


How to influence culture was originally published in Signal v. Noise on Medium, where people are continuing the conversation by highlighting and responding to this story.

Read the whole story
grudes
42 days ago
reply
Share this story
Delete

What is Little Data? And Why Do Project Managers Need It?

1 Share

One of the fastest-growing technology trends today is Big Data, probably behind Internet of Things and ahead of Virtual Reality. For instance, a search on the job site Indeed for “Big Data” returned almost 20,000 entries.

But what about Little Data (which only gets four hits on Indeed)?

Big data is mining huge, heterogeneous data sets and pulling out subtle information that can inform all sorts of decisions.

Let’s look at climate change science as an example. Data comes from atmospheric measurements over Hawaii, temperature data across the globe, ice cores from Antarctica and Greenland, underwater measurements from all the world’s seas, and more. Some of the data were taken by satellite last week; others written in notebooks centuries ago.

[Further Reading: How to Be a Project Team of the Future: Preparing for Industry 4.0]

It’s been pored over by scientists from every country in the world. The data and analysis needed to predict how the climate is changing and will change is complicated. To really understand it requires a PhD. The details are so complex that we have been unable to decisively act on this critical issue.

What Is Little Data?

Little data is the opposite. It’s the 2+2=4 kind of things.

Little data is the obvious observations and conclusions that those paying attention will catch and can use to their advantage. It’s looking outside, seeing it’s raining, and deciding to put on a jacket. It’s noticing that the prices and quality of the food is better at one store than another and using that information to decide where to shop. It’s noticing that if you drink coffee after 5 p.m., you have trouble going to sleep, so you stop drinking coffee after 5 p.m.

Little data has three steps:

  1. Gather data.
  2. Do some straightforward analysis of the data.
  3. Act based on your analysis.

To some extent, little data and big data are close to the same thing, it’s just a matter of degree. The biggest difference is that the analysis for little data is straightforward. If you’re looking for someone with a PhD in math to help with your analysis, that’s not little data. For little data, you should be able to do the analysis in Excel. The challenge is knowing how to respond to your results.

Improve Schedules with Little Data

Here’s a straightforward way to use little data to improve your schedules: record task estimates and actuals. The data should include who did the estimation and the work. Using a pivot table in Excel, you can see which estimators typically underestimate or overestimate. You can also see which of your team members take more or less time than was predicated. There are many ways this data can improve your organization, including:

  • Decrease the bias of future estimations
  • Identify team members who are not using best practices (and therefore take longer)
  • Identify team members who have practices you should transfer to other team members

As is often the case, data acquisition is straightforward, analysis simple, and the response requires further digging.

Measuring KPIs

Key Performance Indicators (KPIs) are a common little data management technique. Leadership decides that certain easily measurable metrics are key to the organization’s success, targets are set, and data acquired. If the performance does not reach the target, then some form of response is taken.

For example, you may be managing a manufacturing line. Your KPI is the number of units manufactured per hour. In creating the manufacturing process, you know you can build 100 units an hour, so you set your target at 80 units an hour to account for the normal hiccups (e.g. you’re training a new team member).

[Further Reading: AI, IoT, and the Future of Manufacturing]

Data collection and analysis are easy. If you’re meeting your target, you can move on to other issues or raise the target. Ideally, if you don’t meet your target, the response is agreed to prior to acquiring the data. Often it just indicates you need to dig deeper, as in this case. As is all small data analysis, the challenge is in the response, not acquiring or analyzing the data.

A Real-Life Example: Test Scores

One of the most controversial examples of little data are standardized school tests. The data is homogenous and straightforward (if time consuming) to collect. The naïve analysis is trivial (average score by grade and school). The response is complex and fraught with challenges.

In 2010, an elementary school near my house was labeled as failing according to the No Child Left Behind law. A majority of the students were from refugee and immigrant families. Many didn’t speak English at home, which certainly posed a challenge for the school.

The metric, test scores, didn’t determine what action was called for, but made clear there was a problem. The district responded by bringing in a new principal and new teachers, and a concerted effort was undertaken to improve performance.  After four years, the performance of the school went from one of the worst schools in the state to only a bit worse than the average school. The little data approach showed that by the metrics we use, the interventions improved the performance.

But this same metric can be misused. There are two middle schools near our house, and we choose to send our son to the one with lower test scores. The school our son goes to is incredibly diverse (including most of the kids who went to the formerly failing elementary school), with a great vibe and dedicated teachers. Test scores can tell you when a school is broken, but it’s not useful in comparing two functional schools. How a school fosters creativity, teamwork, and curiosity are not captured in any test.

This same data can also be used in a big data analysis. Throw in demographic data from the census, housing prices from the country, income data from the IRS, alcohol and cannabis consumption data from Washington State and some subtle correlations that aren’t immediately apparent might appear.

Of course, they might just be random chance; that’s why you need to be careful with big data in a way that you don’t with little data. If your school has the lowest test scores in the state, you know you have a problem. If there’s a weak positive correlation between playing sports and grades, that doesn’t mean every child needs to immediately join a league.

It can be hard to rally the troops to fix a broken team or process. When you come in with data showing how far you are from where you’re supposed to be, it’s much easier to drive changes.  That’s true whether it’s replacing a principal or fixing a broken manufacturing process.

Use Data Thoughtfully

Throughout your day, you’re inundated with data. The key to both little data and big data is to thoughtfully filter out what is unimportant and turn what is important into knowledge, which is data with context and meaning. Then you use that knowledge to inform your actions. If the data can’t lead to action, it’s worthless. An extreme example of this is Sherlock Holmes’s lack of interest in the fact that the Earth orbits the sun,

“What the deuce is it to me?” he interrupted impatiently: “you say that we go round the sun. If we went round the moon it would not make a pennyworth of difference to me or to my work.”

Though, as a former astronomer, I don’t encourage following Holmes’s example, it is important to focus our efforts on data, big or small, that help us make better decisions.

The post What is Little Data? And Why Do Project Managers Need It? appeared first on LiquidPlanner.

Read the whole story
grudes
49 days ago
reply
Share this story
Delete

Making Remote Work: Behind the Scenes at Stack Overflow

1 Share

The logistics of Stack Overflow’s remote-first philosophy

By now you’ve probably heard about Stack Overflow’s commitment to making remote work, well… work. If not, you can read about it here, here, and a whole page of links here. Seriously, we care about it a LOT. At Stack Overflow we want to hire the best person for the job, even if that person is in Salt Lake City, Utah; Berlin, Germany; or São Paulo, Brazil. Promoting remote work promotes diversity, and we are committed to improving both.

However, this isn’t going to be another article about why we believe in remote work. I’m here to tell you about how we pull the whole thing off. I manage workplace operations for the company, and a huge part of that job is making sure that our 85+ remote employees have everything that they need to get their jobs done. So here are my tips for having a successful remote infrastructure:

Have a dedicated remote person (like me!) to be the point person for remote needs.

This is definitely the most important piece of the remote puzzle. You need a person whose stated job is to make sure that remote employees have a specific person for questions, concerns, and problems. When we hire a new remote employee, I tell them that they can come to me with any type of question, and I will try my best to answer it, or at least point them in the right direction.

I get aaaaaall kinds of questions and requests. For instance, I now know how to buy and ship Belgian beer to Poland for an employee that wasn’t able to attend a work event because of a surgery. Also FYI, Uruguay has very strict restrictions on voltage of household items, so getting a crank-lever standing desk to Montevideo was fun (read: not fun).

There also needs to be someone on the executive team (it’s better if there is more than one someone) consistently asking “What about the remotes?” When you have a new “x,” the execs should be thinking about how that impacts all employees, including remotes.

Have your People and Finance Teams homed in on remote needs

Companies will encounter a wide range of odd legalities in dealing with remote employees, especially with international folks. Did you know that in Romania if someone is going to have a home office, they have to have it inspected by a fire marshal? And in the U.S. we have a rule called “prevailing wage determination” that requires some remote employees to post a paper notice in their home for at least 10 days. (I like to think they put it in a laundry room or over the toilet.)

It definitely helps to have an HR department that is certified in immigration and visa issues. At Stack Overflow we are lucky enough to have a lawyer on our People Team along with other trained HR counsels for employees to go to when these issues arise. The same goes for finance departments. The taxation alone is a handful with multiple states/countries. You need an entity for each state, which requires considerable forethought. You also have to file payrolls properly and that varies depending on location. No one ever accused the IRS of being simple!

Remote first

We’ve already touched on this in the other blog posts, but it bears repeating: If one person in the meeting is remote, we’re all remote. If there are 5 people in a conference room and 2 people dialing in remotely, it is very easy for the folks in the meeting room to forget about the people dialed in. You can eliminate that problem by having everyone call in, if possible. After a while it is second nature to jump on a call instead of finding a room. Currently in the Stack Overflow NYC office it is really common to walk around and see two people on a hangout even though their offices are next to each other! (It is also possible that these people are just lazy…)

Try to recreate office fun stuff in a remote capacity

We have regular “Bev Bashes” and holiday parties in the offices, but what about the remotes? How do you give them fun stuff even though they are scattered all over the world?

For starters, we have “Remote Bev Bashes” over Zoom every Friday. The “Bev Baron” for that week (nominated by the last Bev Baron) schedules a Zoom call and sets a theme. Employees grab a beverage of their choice and just chat. You can stay for just a few minutes to say hi, or you can be a part of the entire thing.

Additionally, each office has a pretty fancy Holiday party in December, so we of course invite any remotes that are near the offices. If they are too far away to attend, we give a $200 stipend so that they can have their own festivities, whether it’s a really nice night out with their partners or just a big dinner for family. We don’t care as long as the employee does something yummy with it.

Don’t forget: If you make swag (t-shirts, hats, new socks etc) make sure that you send them to the remotes too. It may seem like a lot of work (believe me, with 87 remotes, it is a lot of shipping), but it is definitely worth it!

Bring them all together

Once a year, we bring all of our remote employees together for a week for some much needed face-time. It’s a different city each time, and there are usually 3 days of Executive Keynotes, Tiny Talks, and many many games of Werewolf. We talk about the state of the company and new projects and teams, but we vow not to make any huge decisions or business altering plans. The focus is on camaraderie, not profits. We look forward to it all year, and it’s definitely a blast. No pressure on the person that has to plan it, right? Read: That’s also me.

We also have smaller mini-meetups for teams to come together when needed, but those are coordinated by the teams themselves and centered around one of our three offices.

Make their home workspaces as awesome as the offices

When a new remote employee is hired, I contact them for their furniture choices. They get their choice of the exact same desks and chairs that we have in the offices, free of charge. We want them to be as comfortable as possible, and that means if they want to stand instead of sit, no problem. Our IT dept sets them up with all of their tech, and I set them up with everything else.

Need a filing cabinet? Cool. You want a different type of desk that is bright pink and sings? Hey, it’s your house. We re-create the in-office set-ups as much as possible so that our remote employees never feel less valued than everyone else.

Want to go remote yourself?

Love remote work or the idea of it? Check out our Live + Work Anywhere job listings on Stack Overflow Jobs.

The post Making Remote Work: Behind the Scenes at Stack Overflow appeared first on Stack Overflow Blog.

Read the whole story
grudes
64 days ago
reply
Share this story
Delete

An event for CSS position:sticky

1 Share

An event for CSS position:sticky

TL;DR

Here's a secret: You may not need scroll events in your next app. Using an IntersectionObserver, I show how you can fire a custom event when position:sticky elements become fixed or when they stop sticking. All without the use of scroll listeners. There's even an awesome demo to prove it:

View demo | Source

Introducing the sticky-change event

An event is the the missing feature of CSS position:sticky.

One of the practical limitations of using CSS sticky position is that it doesn't provide a platform signal to know when the property is active. In other words, there's no event to know when an element becomes sticky or when it stops being sticky.

Take the following example, which fixes a <div class="sticky"> 10px from the top of its parent container:

.sticky {
  position: sticky;
  top: 10px;
}

Wouldn't it be nice if the browser told when the elements hits that mark? Apparently I'm not the only one that thinks so. A signal for position:sticky could unlock a number of use cases:

  1. Apply a drop shadow to a banner as it sticks.
  2. As a user reads through your content, record analytics hits to know their progress.
  3. As a user scrolls the page, update a floating TOC widget to the current section.

With these use cases in mind, we've crafted an end goal: create an event that fires when a position:sticky element becomes fixed. Let's call it the sticky-change event:

document.addEventListener('sticky-change', e => {
  const header = e.detail.target;  // header became sticky or stopped sticking.
  const sticking = e.detail.stuck; // true when header is sticky.
  header.classList.toggle('shadow', sticking); // add drop shadow when sticking.

  document.querySelector('.who-is-sticking').textContent = header.textContent;
});

The demo uses this event to headers a drop shadow when they become fixed. It also updates the new title at the top of the page.

In the demo, effects are applied without scrollevents.

Scroll effects without scroll events?

Terminology
Structure of the page.

Let's get some terminology out of the way so I can refer to these names throughout the rest of the post:

  1. Scrolling container - the content area (visible viewport) containing the list of "blog posts".
  2. Headers - blue title in each section that have position:sticky.
  3. Sticky sections - each content section. The text that scrolls under the sticky headers.
  4. "Sticky mode" - when position:sticky is applying to the element.

To know which header enters "sticky mode", we need some way of determining the scroll offset of the scrolling container. That would give us a way to calculate the header that's currently showing. However, that gets pretty tricky to do without scroll events :) The other problem is that position:sticky removes the element from layout when it becomes fixed.

So without scroll events, we've lost the ability to perform layout-related calculations on the headers.

Adding dumby DOM to determine scroll position

Instead of scroll events, we're going to use an IntersectionObserver to determine when headers enter and exit sticky mode. Adding two nodes (aka sentinels) in each sticky section, one at the top and one at the bottom, will act as waypoints for figuring out scroll position. As these markers enter and leave the container, their visiblitiy changes and Intersection Observer fires a callback.

Without sentinel elements showing
The hidden sentinel elements.

We need two sentinels to cover four cases of scrolling up and down:

  1. Scrolling down - header becomes sticky when its top sentinel crosses the top of the container.
  2. Scrolling down - header leaves sticky mode as it reaches the bottom of the section and its bottom sentinel crosses the top of the container.
  3. Scrolling up - header leaves sticky mode when its top sentinel scrolls back into view from the top.
  4. Scrolling up - header becomes sticky as its bottom sentinel crosses back into view from the top.

It's helpful to see a screencast of 1-4 in the order they happen:

Intersection Observers fire callbacks when the sentinels enter/leave the scroll container.

The CSS

The sentinels are positioned at the top and bottom of each section. .sticky_sentinel--top sits on the top of the header while .sticky_sentinel--bottom rests at the bottom of the section:

Bottom sentinel reaching its threshold
Position of the top and bottom sentinel elements.
:root {
  --default-padding: 16px;
  --header-height: 80px;
}
.sticky {
  position: sticky;
  top: 10px; /* adjust sentinel height/positioning based on this position. */
  height: var(--header-height);
  padding: 0 var(--default-padding);
}
.sticky_sentinel {
  position: absolute;
  left: 0;
  right: 0; /* needs dimensions */
  visibility: hidden;
}
.sticky_sentinel--top {
  /* Adjust the height and top values based on your on your sticky top position.
  e.g. make the height bigger and adjust the top so observeHeaders()'s
  IntersectionObserver fires as soon as the bottom of the sentinel crosses the
  top of the intersection container. */
  height: 40px;
  top: -24px;
}
.sticky_sentinel--bottom {
  /* Height should match the top of the header when it's at the bottom of the
  intersection container. */
  height: calc(var(--header-height) + var(--default-padding));
  bottom: 0;
}

Setting up the Intersection Observers

Intersection Observers asynchronously observe changes in the intersection of a target element and the document viewport or a parent container. In our case, we're observe intersections with a parent container.

The magic sauce is IntersectionObserver. Each sentinel gets an IntersectionObserver to observer its intersection visibility within the scroll container. When a sentinel scrolls into the visible viewport, we know a header become fixed or stopped being sticky. Likewise, when a sentinel exits the viewport.

First, I set up observers for the header and footer sentinels:

/**
 * Notifies when elements w/ the `sticky` class begin to stick or stop sticking.
 * Note: the elements should be children of `container`.
 * @param {!Element} container
 */
function observeStickyHeaderChanges(container) {
  observeHeaders(container);
  observeFooters(container);
}

observeStickyHeaderChanges(document.querySelector('#scroll-container'));

Then, I added an observer to fire when .sticky_sentinel--top elements pass through the top of the scrolling container (in either direction). The observeHeaders function creates the top sentinels and adds them to each section. The observer calculates the intersection of the sentinel with top of the container and decides if it's entering or leaving the viewport. That information determines if the section header is sticking or not.

/**
 * Sets up an intersection observer to notify when elements with the class
 * `.sticky_sentinel--top` become visible/invisible at the top of the container.
 * @param {!Element} container
 */
function observeHeaders(container) {
  const observer = new IntersectionObserver((records, observer) => {
    for (const record of records) {
      const targetInfo = record.boundingClientRect;
      const stickyTarget = record.target.parentElement.querySelector('.sticky');
      const rootBoundsInfo = record.rootBounds;

      // Started sticking.
      if (targetInfo.bottom < rootBoundsInfo.top) {
        fireEvent(true, stickyTarget);
      }

      // Stopped sticking.
      if (targetInfo.bottom >= rootBoundsInfo.top &&
          targetInfo.bottom < rootBoundsInfo.bottom) {
       fireEvent(false, stickyTarget);
      }
    }
  }, {threshold: [0], root: container});

  // Add the top sentinels to each section and attach an observer.
  const sentinels = addSentinels(container, 'sticky_sentinel--top');
  sentinels.forEach(el => observer.observe(el));
}

The observer is configured with threshold: [0] so its callback fires as soon as the sentinel becomes visible.

The process is similar for the bottom sentinel (.sticky_sentinel--bottom). A second observer is created to fire when the footers pass through the bottom of the scrolling container. The observeFooters function creates the sentinel nodes and attaches them to each section. The observer calculates the intersection of the sentinel with bottom of the container and decides if it's entering or leaving. That information determines if the section header is sticking or not.

/**
 * Sets up an intersection observer to notify when elements with the class
 * `.sticky_sentinel--bottom` become visible/invisible at the botton of the
 * container.
 * @param {!Element} container
 */
function observeFooters(container) {
  const observer = new IntersectionObserver((records, observer) => {
    for (const record of records) {
      const targetInfo = record.boundingClientRect;
      const stickyTarget = record.target.parentElement.querySelector('.sticky');
      const rootBoundsInfo = record.rootBounds;
      const ratio = record.intersectionRatio;

      // Started sticking.
      if (targetInfo.bottom > rootBoundsInfo.top && ratio === 1) {
        fireEvent(true, stickyTarget);
      }

      // Stopped sticking.
      if (targetInfo.top < rootBoundsInfo.top &&
          targetInfo.bottom < rootBoundsInfo.bottom) {
        fireEvent(false, stickyTarget);
      }
    }
  }, {threshold: [1], root: container});

  // Add the bottom sentinels to each section and attach an observer.
  const sentinels = addSentinels(container, 'sticky_sentinel--bottom');
  sentinels.forEach(el => observer.observe(el));
}

The observer is configured with threshold: [1] so its callback fires when the entire node is within view.

Lastly, there's my two utilities for firing the sticky-change custom event and generating the sentinels:

/**
 * @param {!Element} container
 * @param {string} className
 */
function addSentinels(container, className) {
  return Array.from(container.querySelectorAll('.sticky')).map(el => {
    const sentinel = document.createElement('div');
    sentinel.classList.add('sticky_sentinel', className);
    return el.parentElement.appendChild(sentinel);
  });
}

/**
 * Dispatches the `sticky-event` custom event on the target element.
 * @param {boolean} stuck True if `target` is sticky.
 * @param {!Element} target Element to fire the event on.
 */
function fireEvent(stuck, target) {
  const e = new CustomEvent('sticky-change', {detail: {stuck, target}});
  document.dispatchEvent(e);
}

That's it!

Final demo

We created a custom event when elements with position:sticky become fixed and added scroll effects without the use of scroll events.

View demo | Source

Conclusion

I've often wondered if IntersectionObserver would be a helpful tool to replace some of the scroll event-based UI patterns that have developed over the years. Turns out the answer is yes and no. The semantics of the IntersectionObserver API make it hard to use for everything. But as I've shown here, you can use it for some interesting techniques.

Another way to detect style changes?

Not really. What we needed was a way to observe style changes on a DOM element. Unfortunately, there's nothing in the web platform APIs that allow you to watch style changes.

A MutationObserver would be a logical first choice but that doesn't work for most cases. For example, in the demo, we'd receive a callback when the sticky class is added to an element, but not when the element's computed style changes. Recall that the sticky class was already declared on page load.

In the future, a "Style Mutation Observer" extension to Mutation Observers might be useful to observe changes to an element's computed styles. position: sticky.

Read the whole story
grudes
79 days ago
reply
Share this story
Delete

Viewing Software Engineers Through The Lens Of The Milgram Experiment On Obedience To Authority Figures

1 Share
Ben Nadel considers the software engineer through the lens of the Milgram Experiment on Obedience to Authority Figures. And, attempts to build better empathy and understanding through the constraints of culture as opposed to the intent of the individual....
Read the whole story
grudes
85 days ago
reply
Share this story
Delete

Dwelling On The Past: The Importance Of Project Retrospectives (Part 1)

1 Share

   

We should always look for opportunities to grow and improve. Retrospectives and reflections allow you to codify what you’ve learned from experience, to document mistakes and avoid future ones, and to increase your potential to grow in the future.

Dwelling On The Past: The Importance Of Project Retrospectives (Part 1)

Agile methodologies typically include time for retrospectives throughout a project. Regardless of your methodology, all teams would benefit from having a retrospective at the conclusion of a project.

The post Dwelling On The Past: The Importance Of Project Retrospectives (Part 1) appeared first on Smashing Magazine.

Read the whole story
grudes
99 days ago
reply
Share this story
Delete
Next Page of Stories