Addy Osmani

“It takes 23 minutes to recover after an interruption“

Studies suggest that it takes 23 minutes to fully recover after an interruption. Factor in the “resumption lag“–the mental warm-up to re-engage–and you're basically running a marathon with shoelaces untied. I cover this topic of context switching in my new write-up on LeadDev: https://lnkd.in/gN42nMeA

If you can't go even 23 minutes without being interrupted, you’ll never be able to do “deep work.“ In other words, all these constant interruptions mean you can never reach the state of deep focus and attention that creative work requires. 

When you task-switch, part of your focus lingers with the previous task. Let's call it “mental clutter,“ and it's like background apps on your phone. Each adds a tax to your cognitive performance. You think you’re multitasking, but you're playing a game rigged against you.

Workspace vibes

Context shifts come in various flavors—self-imposed breaks, pending reviews, unexpected meetings, or just the usual avalanche of Slack pings.
The environment matters. A workspace culture that respects focus and minimizes the casual “Hey, can we chat?“ disruptions can be transformative. Know when to Slack, when to call, and for Pete’s sake, honor the “Do Not Disturb“ status.

How can you reduce the costs of context switching?

Get that stuff out of your head

Your brain's a powerhouse for problem-solving and creative thinking, not a sticky note board. Each new task you remember is like an extra tab open in your browser. A simple way around this? Write things down. Whether it's a good old notepad or a digital task manager, make that your go-to place for stashing tasks for later. That way, you're not juggling mental balls all day. It's like the best way to say to your brain, “Relax, I got this.“

Be ruthless with priorities

If you don't know what your top priority is, you're in a ship without a compass. You're going to drift. Pick a system that works for you, whether it's the Eisenhower matrix to sort out what's urgent vs. important or something like Objectives and Key Results (OKRs) to stay focused.

Make time your friend

Once you're armed with your priorities, it's time to lock them into your day. You don't want to keep task-switching. Instead, batch similar tasks together. Need to go through emails? Allocate a time for that. And seriously stick to it. Use time-blocking techniques like Pomodoro to keep yourself in check.

Wrapping up

Cutting down on context switching isn't just about time management; it's about mind management. Make these techniques part of your daily routine,, and you'll see how much more you get done. I've been intentionally chipping away at my own context switching costs at Google and hope these tips help.

(The study is by Gloria Mark and she expanded on findings in this interview: https://lnkd.in/gnCyyaQ9)

#productivity #work #motivation #timemanagement

“Vibe Coding !== Low Quality Work: a guide to responsible AI-assisted dev“

✍️ My latest free article: https://lnkd.in/gjMdjMWV

The allure of “vibe coding“ – using AI to “move faster and break even more things“ – is strong. AI-assisted development is undeniably transformative, lowering barriers and boosting productivity. But speed without quality is a dangerous trap.

Relying uncritically on AI-generated code can lead to brittle “house of cards“ systems, amplify tech debt exponentially, and introduce subtle security flaws. Volume ≠ Quality.

A helpful mental model I discuss (excellently illustrated by Forrest Brazeal) is treating AI like a “very eager junior developer.“ It needs guidance, review, and refinement from experienced hands. You wouldn't let a junior ship unreviewed code, right?

So how do we harness AI's power responsibly? I've outlined a field guide with practical rules:

✅ Always review: Treat AI output like a PR from a new hire.
✅ Refactor & test: Inject engineering wisdom – clean up, handle edge cases, test thoroughly.
✅ Maintain standards: Ensure AI code meets your team's style, architecture, and quality bar.
✅ Human-led design: Use AI for implementation grunt work, not fundamental architecture decisions.

The goal isn't to reject vibe coding, but to integrate it with discipline. Let's use AI to augment our craft, pairing machine speed with human judgment.

#softwareengineering #programming #ai

“Unhealthy conflict vs. healthy conflict“

Conflict is an inevitable part of life. Be it within a family, between friends, or in a workplace, disagreements and differences in perspective will always arise. However, conflict doesn’t have to be destructive. Let's explore the difference between healthy conflict and unhealthy conflict, and how harnessing the positive aspects of conflict can help with growth.

Unhealthy Conflict: The “You vs. Me“ Paradigm

Unhealthy conflict is characterized by an adversarial mindset, where the folks involved view each other as opponents. This “You vs. Me“ paradigm perpetuates a blame culture and creates an environment where the focus is on personal victory rather than resolving the issue. Key features of unhealthy conflict include:

- Defensiveness: Parties are more concerned with protecting themselves and proving they are right rather than listening and understanding the other’s point of view.
- Personal Attacks: The conversation turns into a personal attack, veering away from the core issue.
- Negative Emotions: High levels of frustration, anger, or resentment are present.
- No Resolution or Compromise: The conflict ends without any resolution, often leading to lingering tension.

Healthy Conflict: The “You + Me vs. The Problem” Paradigm

Contrasting unhealthy conflict, healthy conflict involves viewing the disagreement as a problem to be solved collaboratively. This “You + Me vs. The Problem“ mindset fosters an atmosphere of cooperation and mutual respect. Here’s what characterizes healthy conflict:

- Focus on the Issue: The discussion remains centered on the issue at hand, without digressing into personal attacks or unrelated matters.
- Active Listening: Participants genuinely listen to each other’s perspectives.
- Constructive Feedback: Instead of criticizing the person, feedback is directed at the problem or behavior in question.
- Positive Emotions: There is an underlying sense of respect, even when emotions run high.
- Resolution and Growth: The conflict leads to a resolution or compromise and serves as a learning experience.

Turning The Tide: How to Cultivate Healthy Conflict

Here are some strategies to foster a culture of healthy conflict, whether in your personal life or at the workplace:

- Set Ground Rules: Establish basic principles of respectful communication. This sets the tone for how disagreements will be handled.
- Practice Active Listening: Focus on understanding the other person’s perspective without immediately formulating a response.
- Use “I“ Statements: Frame your thoughts in terms of how you feel and what you have observed. This minimizes defensiveness and promotes open dialogue.
- Seek Common Ground: Identify areas of agreement and build upon them.
- Offer and Accept Compromises: Be willing to make concessions and acknowledge when the other party does the same.

Healthy conflict can be a catalyst for growth.

Illustration credit: Liz Fosslien

#productivity #motivation #growth #learning

Tip: supports lazy-loading, async decoding & much more. Learn about them in my post for StackOverflow: https://bit.ly/soimgs

A few more recent posts on you might appreciate:

Avoiding layout shifts: aspect-ratio vs width & height:
https://lnkd.in/gSpFJpCP by Jake Archibald

Optimizing resource loading with Priority Hints (for LCP):
https://lnkd.in/gwJ5xu3v by Leena, Patrick Meenan and I

Optimizing Largest Contentful Paint (recent refresh):
https://lnkd.in/gdFQm3sw by Philip Walton

#webperformance #webdevelopers

Tip: Chrome DevTools has a Shadow Editor built in!

Shadows and depth are a common aspect of design these days. We want to help you tweak those shadows so your UI stands out just right on your page. That’s why DevTools has a shadow editor baked right in.

You can access the Box Shadow editor and Text Shadow editor from Elements > Styles. Using the Box-Shadow editor as an example from my video, you can control:

The shadow type - Outset or inset
The X offset - The horizontal shadow position
The Y offset - The vertical shadow position
The Blur - Distance of the blur
The Spread - The size of the shadow

Changes you make in the shadow editor also apply to the Styles pane CSS.

#devtools #programming #webdevelopers #css #ui

~ “Great software engineers build throwaway prototypes to showcase their ideas. It's easier to reason about concrete code than abstract ideas “ - Gergely Orosz

Why Prototypes Matter

Prototyping enables us to quickly visualize, and iterate on ideas in a shareable way before committing to full-fledged development. Ideally it's a low-cost way to the bridge an abstract idea and a tangible product. A working model, even if it's primitive and incomplete, facilitates deeper, more effective communication than mere verbal or written descriptions.

Great software architects understand that a prototype helps the entire team - developers, stakeholders, and even end-users - get a better sense of how the eventual solution will look and function. In addition, it allows them to grasp the potential challenges that might crop up during the actual implementation.

Speaking the Language of Code

When it comes to problem-solving, great software engineers often turn to their most expressive language - code. Through prototypes, these engineers are able to communicate complex ideas in a language that not only they understand but also the machines that will ultimately carry out their instructions.

Prototypes offer an almost tangible representation of an idea. By using code to present an idea, architects can articulate nuances that might otherwise be difficult to convey through conventional just language.

Embracing the Throwaway Nature

A noteworthy aspect of this process is the acceptance that many prototypes will be discarded. Great architects are not afraid of their work being labeled as 'throwaway'. They understand the fundamental role of these prototypes: not to be the final product, but to serve as a vehicle for refining ideas, identifying potential roadblocks, and accelerating understanding.

This iterative process is crucial to avoid the dreaded “analysis paralysis“. By building, testing, and refining (or discarding) prototypes, software architects can continue making progress instead of getting stuck trying to perfect an abstract idea that has yet to face reality.

Cultivating a Culture of Prototyping

Prototyping, however, is more than just a tool. It's a mindset and a culture that needs to be cultivated within a development team. As leaders, architects should encourage their peers to voice their ideas not only in meetings but also in code.

Building prototypes promotes a proactive, hands-on approach to problem-solving and idea validation. It fosters an environment where engineers are motivated to take charge of their ideas and bring them to life, creating a more engaged, innovative, and dynamic team.

So, the next time you find yourself wrestling with a complex problem or trying to communicate an abstract idea, consider translating your thoughts into code. It doesn't have to be perfect, or even close to the final solution. It just needs to be good enough to illustrate your point.

#softwareengineering #programming #developers

“If something has a minor issue, repair it. Minor issues become major issues over time.“ - Sahil Bloom

We've all heard the saying “Don't sweat the small stuff,“ but what if the “small stuff“ isn't so small after all? Whether it's a subtle bug in your code, a ticking noise in your car, or that thing you wish you'd said to a friend but didn't, minor issues have a way of compounding over time. Today, let's talk about why it's crucial to tackle these issues head-on.

The Technology Analogy

Let's consider this from a developer's perspective. You notice a tiny memory leak in your software. It seems insignificant, so you let it slide. Over time, this leak turns into a flood, causing performance to degrade and potentially leading to crashes. By waiting, you've not only compounded the issue but also created a terrible user experience.

Friendships and Code Reviews Aren't That Different

Think of your friendships like a long-term collaborative project. A missed call or an unresolved argument might seem trivial initially. However, much like unattended code issues, these emotional “bugs“ can become features of the relationship—negative features that neither you nor your friend enjoy. So, review your actions and communications regularly; keep things “clean“ just like you would your codebase.

A Healthy Approach to Life

Ever postponed a doctor's appointment for a nagging issue? I have, guilty as charged. These deferred medical appointments can be like ignored compiler warnings. They might not stop the system today, but they can certainly lead to catastrophic failures down the line.

The DIY Dilemma at Home

We often overlook the importance of home maintenance, but here, too, the little things count. A creaking door or a crack in the wall might seem like inconveniences, but left unattended, they can turn into bigger problems. Don't postpone; be your own “home debugger“ and fix them ASAP.

The Silent Cost: Mental Load

One often overlooked aspect is the mental load carried by these unresolved issues. They occupy valuable cognitive space, leaving you less capable of dealing with other life complexities. This is the “background processing“ of your life, and it needs to be optimized just like your system's resources.

The Cascade Effect

Whether it's a string of code or a string of events in life, small problems often have a ripple effect, creating unforeseen issues in unrelated areas. Fixing a minor issue now often prevents a cascade of problems later.

Conclusion

The philosophy of immediately addressing minor issues helps in achieving long-term stability, whether it's in your professional code, your personal relationships, your health, or even your home. So, the next time you encounter a minor issue, remember that fixing it is an investment in your future success and peace of mind.

To live a 'bug-free' life, start debugging now.

Illustration by GoLimitless

#productivity #motivation #work #growth

Introduced Jules - an asynchronous coding agent from Google that plans, implements and creates pull requests for you! Now in beta.

Jules (https://jules.google/) is an autonomous coding agent that understands your intent, writes and reads code, and gets to work in the background, freeing you up to focus on higher-level tasks. Think of it like a scalable Cursor you run in the background.

Some key capabilities:

- Works on real codebases: No sandbox limitations here! Jules clones your codebase into a secure VM and understands the full context of your project.

- Parallel execution: It handles multiple requests simultaneously, running tasks inside a cloud VM.

- Visible workflow & User steerability: Jules shows you its plan and reasoning before making changes, allowing you to maintain control.

- GitHub integration: Works directly inside your GitHub workflow – no context-switching needed!

- Audio summaries: Listen to recent commits and project history in a contextual changelog.

This is a game-changer for writing tests, building new features, providing changelogs, fixing bugs, and bumping dependency versions. Jules leverages Gemini 2.5 Pro and a cloud VM system for advanced coding reasoning and handling complex tasks.

Currently in public beta, and it's free to use (with usage limits for now). This is definitely something to keep an eye on as we move towards more intelligent and autonomous development workflows. Congrats to Kathy K. and team!

More to come from #GoogleIO soon!

#ai #softwareengineering #programming

“Discipline is not about perfection. It’s about continuity”


Credit: GoLimitless for their visualization

#softwareengineering #productivity

The Lighthouse Treemap in Chrome DevTools visualizes what's in the JavaScript you ship. Discover what to reduce based on module size, coverage and duplicate dependencies.

Good guides on the feature, also available on PageSpeed Insights:

https://lnkd.in/gQZMT6dT
https://lnkd.in/gccyKXfw

#javascript #webdevelopment #webperformance

Giveaway time! I have 20 signed copies of Learning JavaScript Design Patterns or Image Optimization for grabs :)

To enter, like this post and comment with something you learned this year. It can be a tech tip, knowledge, insight or anything that helped you grow.

Competition is open to everyone. I'm happy to ship globally. Will keep this open for a few days and then update the post to mention winners.

Update (July 19th): Okay, that's a wrap on the competition! I'll be going through all the entries soon and will post who the lucky winners are.

#programming #webdevelopment #javascript

“A bad day is not a bad year”

No single day defines our whole journey.

We all have bad days from time to time. Days where it feels like nothing is going right, setbacks are piling up, and our outlook turns bleak. In those difficult moments, it's natural to get discouraged and let the negativity cloud our perspective.

However, it's crucial to remember that no single day, no matter how challenging, defines our overall journey. Just like the image shows, a bad day is just a small dip in the grand scheme of an upward trajectory. The key is not to let temporary lows derail our long-term progress and goals.

When you're in the midst of a rough patch, take a step back to regain perspective. Reflect on how far you've come, the obstacles you've already overcome, and the growth you've achieved. Envision the better days ahead and hold fast to your purpose.

Tomorrow is a new day to make positive strides. A bad day, week or even month does not equate to a bad life. You have the strength to rise above the hard times and continue moving forward. Embrace this mindset shift and turn your setbacks into setups for comeback.

Zoom out, keep the faith and know that brighter days are likely on the horizon.​​​​​​​​​​​​​​​​

Illustrated by Michael J Boorman

#motivation #productivity #leadership

“The greatest skill one can develop is reduce the gap between idea and execution“

Why Reducing the Gap Matters

We all have ideas, dreams, and goals. However, what separates the doers from the dreamers is the capacity to execute those ideas. The shorter the gap between your “aha moment“ and taking actual steps towards it, the higher your chances of success.

The Risk of the “Someday Syndrome“

Waiting for the perfect conditions to execute can be paralyzing. Whether it's the resources, time, or the right team, waiting for everything to align could mean you'll wait forever. Procrastination and the “someday syndrome“ don't just defer your plans; they can make them obsolete.

Strategies to Bridge the Gap

Let's dive into how one can make this happen.

Time-Boxing and the Eisenhower Matrix:
When you're hit by a new idea, the first step is to evaluate its urgency and importance. Use the Eisenhower Matrix to classify your tasks into four categories: urgent and important, important but not urgent, urgent but not important, and neither. This can help you allocate your time wisely.

Build a Minimum Viable Product (MVP):
If it's a project or a business idea, the aim should be to build an MVP as quickly as possible. This not only helps you validate the concept but also gives you the momentum to keep going.

Accountability Mechanisms:
Share your plans with someone who can hold you accountable. Regular check-ins can keep you on track and provide you with the feedback loop you need for continuous improvement.

Embrace Failures as Learning Experiences
Failures are inevitable, but they are also invaluable learning experiences. Instead of dwelling on setbacks, focus on the lessons learned and how you can pivot or improve.

Use Project Management Tools:
Tools like Jira, Asana, or Trello can provide a clear roadmap for your project and help you break it down into manageable tasks.

Automate What Can Be Automated:
Leverage tools like Zapier or Integromat to automate repetitive tasks. This saves time and allows you to focus on what truly matters.

Final Thoughts:
Reducing the gap between idea and execution is essentially about creating a well-oiled machine that converts your thoughts into actions. It's a skill, and like any skill, it can be developed through consistent practice, efficient strategies, and the right mindset.

Remember, it's not the idea but the execution that differentiates a successful venture from a mere daydream. So, the next time you have an idea, ask yourself, “What's stopping me from making this happen right now?“

Until next time!

Illustrated by GoLimitlesss - you can check out our free book at https://stoic.im!

#productivity #motivation #work #growth

Tip: Emulate vision deficiencies in Chrome DevTools to see how users who experience color blindness or blurred vision might see your site.

In Chrome 112, we also now support emulating “reduced contrast“: https://bit.ly/112ctrst

Globally, 1 billion people have a near or distant vision impairment impacting how clearly they can see objects, including web pages. Color blindness (color vision deficiency) alone impacts 300 million people worldwide, limiting how well your users may be able to see color as clearly as other people. For example, they may be unable to completely interpret red, green or blue light.

Chrome DevTools has support for emulating color vision deficiencies, helping you better optimize your pages to be inclusive of users with differing levels of color blindness.

Available in the Rendering sub-panel, the feature simulates the following kinds of vision deficiencies:

Blurred vision: Difficulty focusing on fine details.
Protanopia: Difficulity perceiving any red light.
Deuteranopia: Difficulty perceiving any green light.
Tritanopia: Difficulty perceiving any blue light.
Achromatopsia: Difficulty perceiving any color except for shades of grey.

To simulate a vision deficiency:
1. Open the Rendering sub-panel by selecting the ... menu in the toolbar
2. Select the More tools option and then Rendering
3. Scroll to the Emulate vision deficiencies item and use the drop-down menu to display the options available for color vision deficiency emulation.
4. Select an option. The current page should now display the color vision deficiency emulated

Keeping in mind blurred vision and color blindness issues can help ensure that your pages are accessible to the widest range of users possible. Give the feature a spin and if you have any feedback, feel free to share it.

#accessibility #inclusion #webdevelopers

Some best practices for writing code-comments. Often, comments should only answer questions code can't (e.g. the “why“)

Good code should read like a well-written prose, and inline comments act as its annotations. Yet, writing meaningful comments is often overlooked, considered a secondary or trivial task. But a poor or missing comment can confuse or mislead the reader, causing more harm than no comments at all.

Ellen Spertus laid out an excellent framework for how to get code comments right: https://lnkd.in/gKjvHd4N:

Rule 1: Comments should not duplicate the code.
Rule 2: Good comments do not excuse unclear code.
Rule 3: If you can't write a clear comment, there may be a problem with the code.
Rule 4: Comments should dispel confusion, not cause it.
Rule 5: Explain unidiomatic code in comments.
Rule 6: Provide links to the original source of copied code.
Rule 7: Include links to external references where they will be most helpful.
Rule 8: Add comments when fixing bugs.
Rule 9: Use comments to mark incomplete implementations.

Rule 1: Avoid Redundancy
Comments shouldn't echo the code. Redundant comments are mere noise. A comment like i = i + 1; // Add one to i doesn't help anyone. It only distracts.

Rule 2: Clarity Over Comments
If you find yourself writing a comment to make a complicated block of code clear, stop. Rethink and refactor the code first. Good variable naming often obviates the need for comments.

Rule 3: If It's Complicated to Comment, It's Likely Wrong
If you can't write a clear comment for a piece of code, that might be a red flag. Maybe the code is too convoluted or the logic too tangled. Rewrite it.

Rule 4: Clarify, Don't Confuse
Don't let your comments turn into riddles. If a comment generates more questions than it answers, it's a bad comment.

Rule 5: Comment Unidiomatic Code
Sometimes you have to break the usual rules for special cases. When you do, explain why. A well-placed comment can prevent future devs from “fixing“ code that isn't broken.

Rule 6: Attribute Copied Code
If you're lifting code from Stack Overflow/GPT or any other source, provide a link. This is good for both context and complying with licenses.

Rule 7: Link to External References
When your code adheres to a particular standard or responds to an RFC, say so in a comment and link to it.

Rule 8: Comment Bug Fixes
When you fix a bug, leave a breadcrumb for future developers. This might be as simple as a comment pointing to an issue number or explaining the bug's behavior.

Rule 9: Mark Incomplete Code
Sometimes you have to commit code with known limitations. Use a standard TODO format to highlight these. Mention the technical debt and perhaps link to an issue tracker.

Conclusion
Comments don't fix bad code; they complement good code. When done poorly, they obfuscate. Keep these guidelines in mind

#programming #developers #code #work

Tip: Chrome can measure how much unused JavaScript is on your page. Helpful to identify code to remove or lazy-load.

DevTools > three-right menu > More tools > Coverage or for more info read https://bit.ly/unused-js #javascript #webdevelopers

Tip: CSS Scroll Snap can lock the viewport to certain elements after the user finishes scrolling. Ace for advanced interactions.

See https://bit.ly/csssnap and https://bit.ly/scroll-snap to learn more.

#programming #webdevelopers

“We think of failure and success as opposites when In reality failure is a part of success“ - Liz Fosslien

When considering the journey toward achieving our goals, the common mindset is to place failure and success on two opposite ends of the spectrum. However, this binary thinking creates a false dichotomy that often hinders our ability to learn and grow. In reality, failure is not the antithesis of success; it is an integral part of the success equation.

Embracing the Role of Failure

Failure is inherently linked to experimentation. When we try new things, we’re bound to make mistakes. We must accept this as an unavoidable aspect of progression. The moment we detach ourselves from the fear of failure, we create space for creativity and innovation.

Verified Learning as a Catalyst for Growth

Verified Learning is an error-prone process. When we strive to acquire new skills or knowledge, making mistakes is part and parcel of the learning curve. It is through these mistakes that we get a chance to revise, reflect, and re-strategize. If you're not making mistakes here and there, chances are you're not taking the necessary (and often uncomfortable) steps needed to improve. It is important to not only embrace failure but to actively seek it as an opportunity for verification of what works and what doesn’t.

Creating a Feedback Loop

To effectively capitalize on failure, it is imperative to create a feedback loop. We need to understand what went wrong, why it went wrong, and how we can avoid similar pitfalls in the future. This process is essential for transforming failure into a learning opportunity.

Building Resilience Through Failure

Experiencing failure helps build resilience. By understanding that failure is not the end, but rather a step in the journey, we develop the ability to bounce back. This mental toughness is a crucial ingredient for long-term success.

Practical Steps for Embracing Failure

- Reframe Your Mindset: Instead of perceiving failure as a setback, view it as an opportunity for growth.
- Analyze and Learn: After a failure, critically analyze what went wrong and glean lessons from the experience.
- Create a Culture of Experimentation: Whether it’s in your personal life or at the workplace, foster an environment that encourages trying new things without the fear of failure.
- Celebrate Small Wins: Sometimes the road to success is long and winding. Celebrating small victories along the way can provide the motivation needed to keep going.
- Seek Feedback and Iterate: Constantly seek feedback on your performance and be willing to make iterative changes based on this feedback.

By recognizing and embracing the inherent link between failure and success, we can shift our perspective and create a more conducive environment for personal and professional growth.

Illustration credit: Liz Fosslien

#productivity #motivation #work #mindset

“What micromanagers think they do vs. what they actually do“

This illustration by Roberto Ferraro perfectly captures the disconnect between what micromanagers believe they're accomplishing and the reality of their actions. While they may think they're ensuring quality and efficiency by closely monitoring every detail of their team, their excessive control often has the opposite effect.

Micromanagers inadvertently stifle creativity by discouraging independent thought and experimentation. When the team feels constantly watched and second-guessed, they're less likely to take risks or think outside the box. This can lead to a stagnant work environment and missed opportunities for innovation.

Moreover, micromanagement can have a detrimental impact on morale. Teams may feel undervalued and micromanaged, leading to decreased job satisfaction and increased turnover. A culture of fear and dependency is created, where employees are afraid to make mistakes and become reliant on their manager for approval on every decision. This not only hinders productivity but also prevents employees from developing their full potential.

Effective leaders recognize that empowering their teams is essential for success. By trusting folks, providing clear guidance, and offering support when needed, they create a collaborative environment where everyone feels valued and motivated to contribute their best.

#motivation #productivity #leadership

How loading bars actually work

#programming #softwareengineering

“A good manager can change your life.“

The impact of a good manager extends far beyond the confines of your immediate job responsibilities. The influence they wield is profound, shaping not just your daily tasks, but the trajectory of your entire career and personal well-being. I loved this visual by Chris Donnelly and wanted to share it.

The Transformative Power of Effective Management

1. Career Progression and Learning: A good manager doesn’t just oversee your work; they actively invest in your growth. They provide opportunities for learning, ensuring that you are not just completing tasks but also developing skills that will serve you in the long run.

2. Happiness and Job Satisfaction: The quality of your managerial relationship can significantly affect your job satisfaction. With a supportive manager, the workplace transforms into an environment where you feel valued and understood, leading to greater happiness and fulfillment.

3. Nurturing Career Growth: A good manager doesn't only focus on the present but also helps map out a path for your future. They understand your aspirations and work with you to create opportunities that align with your career goals.

Characteristics of a Good Manager
But what exactly constitutes a “good“ manager?

- Empathy and Understanding: They recognize the unique strengths and challenges of each team member, fostering an inclusive environment where everyone feels valued.

- Inspiration and Leadership: Beyond just managing tasks, they inspire their team. Their leadership style motivates and encourages, cultivating a culture of enthusiasm and commitment.

- Skill Development and Motivation: They prioritize the growth of their team’s skills, providing guidance and feedback that accelerates learning and boosts motivation.

- Building Confidence and Productivity: By creating a supportive atmosphere, they help build confidence in their team members, which in turn drives productivity and efficiency.

- Open Communication: A good manager ensures that every voice is heard, providing a safe space for both extroverts and introverts to express themselves and contribute meaningfully.

Beyond Task Management

As a manager, it’s crucial to self-reflect: Are you merely managing tasks, or are you truly managing people? The goal is to be the kind of manager you always wished you had.

Management is more than a role; it’s a responsibility to positively impact the lives of those you lead.

Strive to be the change-maker in someone’s career and life.

For high resolution PDFs of cheat sheets like this, check out the awesome newsletter by Chris: https://lnkd.in/gtzy89Nw

#productivity #motivation #work #growth

Tip: Chrome DevTools shows inactive CSS properties. Hovering explains why the rule has no visible effect. So nice.

A big thank you to the Firefox DevTools team who previously explored a similar idea and have supported this for a few years. This feature is also available in Chromium DevTools so all flavors of the browser should support it.

#softwareengineering #webdevelopers #css

A good list of skills senior engineers need, beyond coding by Camille Fournier https://bit.ly/srenglist #softwareengineering