Interestingly enough, not a single one of the lessons learned by experienced software developers was related to a specific technology or technical skill. Every insight related to soft skills. One take-away from that is that technical aptitude is necessary, but soft skills can't be neglected if a successful tech career is what you want.

Managing Expectations is Important

Expectation management is a common theme when we've asked the Dev Together community about crucial software developer skills in the past. This discussion was no exception.

Overpromise, underdeliver

This time we talked about managing expectations in estimates. A big part of a successful project is a solid estimate. Estimates inform project stakeholders, development managers, users, and other key players. Assuming everything will go well reflects a positive attitude, but experienced developers know that something will always go wrong. Estimates have to take that into account in order to prevent failure in the eyes of stakeholders.

Software's About People

We build software to facilitate someone's job, safely transport them through space, or make sure their paycheck is deposited on time. Approaching software with that in mind helps developers focus on the value it can provide.

Eliminating a small bit of frustration can be worth many times more than a clever code implementation. -rosslarson

The end user is always an important person to keep in mind when working toward a goal, but this maxim extends to other project stakeholders too. For example, considering the needs of developers who will update our work in the future helps us build understandable code. Thinking about the company's objectives in the context of a goal helps us think critically about each part of our systems. Even working with other developers in the team helps us negotiate a considered approach to solving the problems at hand.

Be Able to Work With Multiple Personalities

Software projects are rarely completed by just one person. A software developer needs to be able to adjust for different personality types and work styles. To be successful, a developer must learn to build trust and foster relationships.

Making sure other people feel heard is important in gaining their trust

One way to build trust is to make yourself "vulnerable" to others in the workplace, which creates a trust environment. People are usually more willing to help or forgive when they can empathize with you.

Prioritization Matters

Humans aren't good at multi-tasking. We end up spending a lot of time trying to recover after context-switching.

Being able to look at the "end goal"...helps me assess if a new thing is worth it enough and will help me achieve my end goals. -Cristina Ruth

Prioritizing tasks helps developers apply their full brainpower to one goal instead of scattering it among many. Understanding the end goal and communicating the opportunity cost of changing paths helps people focus on the most valuable or efficient way to achieve the overall goal.

It's a delicate balance of jugging the current and planning for the future so there's less things to juggle. -Cristina Ruth

Find Root Causes

Keep asking "why"? and going down deeper levels until you understand exactly where the source of a problem is coming from. - Fred Turkington

Software developers are problem-solvers. It's a key part of our psyche. Sometimes we get too focused on solving problems and forget to step back to find out what's a symptom and what's causing it - i.e. the real problem. For example, understanding why users want a feature often leads to discovery of an underlying issue that might solve many other problems at the same time.

You Can't Know Everything

Software developers sometimes feel like the world expects them to be an expert in everything. Unfortunately, that's just not a realistic approach. We need to know when to rely on team members and coworkers for their knowledge. A software team that practices this interweaving of skills becomes stronger and more successful as a result.

Learning Never Hurts

Even though developers can't be expected to be experts in everything, learning is how we improve our abilities.

It's good to always challenge ourselves and get ourselves in an always learning mindset

This advice applies to many areas of life, not just software development careers. Sometimes we have to learn through failure, which is also okay - another lesson we learned in this discussion. Expanding knowledge helps identify patterns, too, which is a critical component of software development.

Take Risks

Limiting ourselves to what we already know is attainable prevents us from stretching past superficial goals to find our true limitations. For example, only applying to jobs we feel qualified for will limit our opportunities to learn how to do new things. The "safe" path isn't always the best path.

Conclusion

This Dev Together Madison Let's Discuss event highlighted several valuable lessons learned over the course of many software developer careers. Thank you to everyone who participated!

Communication

Communication of some kind came up in just about every discussion. Developers can help a project become successful by practicing good communication - around requirements, timelines, and difficult topics to name a few. A project suffers missed deadlines, unexpected features, and slow progress when communication within the project is broken. Developers need to clearly communicate with their coworkers, team leads, Quality Assurance, project managers, and project stakeholders.

Negotiation

Successful developers negotiate requirements, time estimates, competing priorities, resource usage, architecture and design, testing levels, etc with people in a variety of roles. They even negotiate with themselves - evaluating options and making trade-offs to find the most appropriate solution to stakeholder goals. Negotiation is a crucial skill in a human-based software project.

Scope Control

Scope can be a touchy subject with stakeholders, but it's a crucial safety net that keeps the project under control. Stakeholders often hold a particular vision of the software in their head without fully explaining it to the development team or other stakeholders. When an important stakeholder makes a casual remark about Feature X she thought would be included, some developers rush to add it at the cost of expanding scope.

Managing scope relies on good communication between project participants. Successful developers call out when the project's scope changes so stakeholders know they can get Feature X, but it will add cost to the project. Agile approaches to software development help curb the impact of scope creep by keeping initial scope small and forcing a re-evaluation every sprint.

Timeline Management

When a stakeholder declares a timeline ultimatum, the project turns into a death march. The developer team is forced to focus on stuffing features in before the deadline and start neglecting quality and testing just to check something off the to-do list.

Projects that have a must do by x date are doomed to have low quality. -Cristina Ruth

Successful developers communicate and negotiate with stakeholders to find a reasonable middle ground instead of slogging toward the project's death. In this scenario the stakeholder has declared the timeline to be the number-one concern. A successful developer helps them understand that the timeline exceeds the scope so scope must be reduced to fit the timeline. In addition, successful developers know how to prioritize their efforts so the most important things get done on time.

I think "under promise and over-deliver" might fit here -Steve

Listening/Comprehension

In order to be successful a developer must understand the work to be performed - and that requires listening. Too often developers miss critical details by declining to ask clarifying questions or drilling down to the root of the problem the stakeholder is trying to solve. Much of software development is about transferring information between people, and being a good listener makes that a lot easier.

Some good resources for learning better communication habits were suggested in the discussion:

• How to Win Friends and Influence People by Dale Carnegie (book) (audiobook)
• 7 Habits of Highly Effective People by Stephen R. Covey (book) (audiobook)
• Crucial Conversations by Patterson, Grenny, McMillan and Switzler (book) (audiobook)
• Simon Sinek (youtube)

Testing

Humans create bugs! A successful software project should have the fewest bugs possible. That means testing is a key to a successful project - and not just for the QA team - developers need to test their code before foisting it off on someone else. A good rule of thumb for developers is if you'd feel comfortable enough to deploy the code you just wrote into production during the busiest day of the year, it's ready for QA.

Always appreciate your testers, even when they find problems in your code. - rosslarson

Public Speaking

Developers have to present things all the time - their opinion on design strategies, feature ideas, proposals, estimates, bad news - to people in a variety of roles. Regardless of who you have to present things to, being comfortable while speaking to an audience makes it easier to gain stakeholder support, persuade coworkers, lay out a plan to the boss - all things that help grease the project's wheels.

Even just webinar presenting is an art -Joe Warbington

A successful developer learns how to be a good public speaker so he can make his case effectively and persuasively. Even presenting over the phone requires a well thought-out approach and path. Presenting to an audience in person takes more practice, but the results are worth it.

Conclusion

Throughout Dev Together Madison's Let's Discuss event, many common themes were raised around building crucial developer skills. Thank you to everyone who participated!

Soliciting External Input

Several discussions wound around the idea of approaching external sources for help, starting with asking "stupid" questions.

They know enough to know how truly little they know starting out and worry that they will be left behind or perceived as low-value if they reveal that fact -Fred Turkington

Junior developers may feel as though they're expected to know all the answers already, resulting in imposter syndrome when they don't. This may be a cultural impediment; if junior developers are routinely criticized or berated for not knowing the answers to their questions, they'll stop asking questions. Senior developers should encourage questions; junior developers will have a difficult time learning without exposure to new information.

As beginners (and even experienced devs), we need to be aware of our limitations and when we are completely stuck, and learn to ask for help from our peers/mentors. -Cristina Ruth

That's not to say developers shouldn't first attempt to solve the problem without help; it's still important for developers to show that they're stuck and not just asking for easy answers.

Hearing "help me with my thing" is annoying, but helping someone who has obviously already put in effort is not. -rosslarson

Asking a specific question and describing the solutions you've already tried is a winning formula, as can be seen across StackOverflow. But the target of your question doesn't even have to be human - rubber-duck debugging came up several times as a great way to look at the problem from a different angle.

Self-directed Searching

Of course, figuring out what to try first isn't always straightforward. The vast expanse of the Internet offers thousands or millions of pages that might come up in a simple Google search. Not all solutions are equal or even valid, which makes a tedious task of sifting through and trying all the possibilities. Learning to search with specificity and accurately judge the value of information sources makes searching for answers far more efficient. Locating technology-specific communities in Slack, Twitter, Reddit, Discord, dev.to, and even local Meetups makes finding targeted, high-quality answers much easier.

Accepting Failure

Some of the event's discussions centered around failure and perceived failure. Like it or not, it's entirely possible the solution a developer's committed to isn't the best one - and that doesn't constitute failure. Allowing your ego to reject all other solutions is failure. "We all make mistakes," typed Cristina Ruth. "There's always something to learn, so it's very important that we don't destroy our self-confidence as we go through learning something new."

Another way to look at accepting "failure" was described by Jacob Zimmerman as "Ask, Then Listen". Being willing to genuinely understand the answer coming from the other side of the table instead of assuming you caught all the important keywords is another form of backing down your ego and accepting that there are still things to be learned.

Failure can be a positive thing when it's considered an opportunity to improve. If something doesn't go well or your solution is torn apart by others, it's OK! Take a moment to understand what went wrong, understand how to fix that for the future, and move on.

There's always something to learn, so it's very important that we don't destroy our self-confidence as we go through learning something new. -Cristina Ruth

Celebrating Small Wins

If you read through the last few paragraphs, it may seem like successful new developers must resign themselves to a dark and dreary life of ego-bruising failure after failure. That's not true! "It's important to take the time to celebrate your accomplishments," Cristina Ruth said - no matter how small the wins are. Don't get overwhelmed - persevere!

Breaking Things Down

Skillfully breaking large problems down into small, digestible chunks is crucial to staying focused in long-term goals, creating winnable tasks, and overcoming failures. This skill has far-reaching value - some of the other applications brought up were:

Learning new technologies by chopping them into manageable chunks

• Demonstrating thought process to others
• Gaining a holistic understanding of an architecture
• Mapping out software requirements
• Building accurate time and cost estimates
• Planning a development strategy for a large project
• Distributing concurrent work
• Troubleshooting software problems
• Attacking problems in general

Conclusion

Throughout Dev Together Madison's Let's Discuss event, many common themes were raised around building crucial developer skills. Identifying when to ask for help, removing ego, staying positive, and deconstructing problems were all well-represented during these discussions. Thank you to everyone who participated!