How to Be a Successful and Responsible Developer?

Sometimes, though not always, successful and productive developers are liable. Responsibility means you know yourself and your own weaknesses, thus keeping you informed of what project demands. I'm going to try to explain who is precisely a professional developer and why it's nice to have one (or more) on deck.


Great, Satisfied... Yet Responsible?

There was an episode of Rusty Rogues concentrating on what makes a developer top-drawer. They followed great developers who had grown in their field. I have mentioned a couple of these people's core strengths here: they function proactively.

We belong to the collective of developers-because of their experience in the public domain we can be role models for us too.

1. We have a mentality of development-they realize that they will improve their most fundamental skill by the commitment and diligent work-the brains and ability are only the starting point.

2. They work proactively.

3. We belong to the collective of developers-their experience in the public domain we can be role models for us too.

4. We have a mentality of development-realize that they will improve their most fundamental skill by the commitment and diligent work-brains and ability are only the starting point.

5. They're great communicators.

6. Accountable May does not Mean Experienced

I've interacted with several people from different backgrounds— with fresh students to senior-ninja-guru developers— and I've found that it doesn't really matter what they've done in the past; it's all about projecting towards the potential.


What happens to a conscientious developer? (WWRDD)

The dev seeks to re-analyze the brief — maybe that's written down already, or maybe there's been a Slack debate. If they are indeed unable to locate anything-they respond to the company with clear queries such as: "I have read via the brief but some of it is very vague-please inform me whether we can take X or Y into account."

The trick here just is being specific-time is a precious tool. But this is not the end of the matter— the dev doesn't hesitate to question the customer (remember-they seem to be very busy). At least the dev will think of any possible options and use his / her own judgement to decide how to create the solution.

In such a situation, allocating your time productively is crucial— don't give yourself the privilege of spending hours on doing nothing. If you can't even move ahead (check twice!), try anything else that can push the idea one step farther.


A couple more tips:

1. Speak to the group, maybe the customer isn't the only person who understands what you need to learn.

2. Don't constantly sit about hoping for a reply— you need to carry on.

3. Understand and be truthful about the limitations/blockers — that's much more helpful than offering anything you can't offer.

4. When you are single, using your own judgement — asking for forgiveness is better than asking for permission.


We Don't Prepare On Fridays!

That is a much more fundamental argument we are not able to work with about taking everything on. When you are mindful that what you are going to introduce is extremely unlikely to operate properly, hold off. I said earlier that it's better to seek forgiveness, but if the chances are against you because only hold off. There could be situations where you're fresh to the project, so you're left alone for a couple of days — maybe it's not the right opportunity to introduce critical code improvements.

Recently, I happened to come across a small-feature pull demand and Rails update buried somewhere in there. The program was intended to process some financial details, but it was very old and required a proper test layer. This functionality was a big incentive to combine, so what if anything went wrong? Moreover, it was the last day until the developer went on holiday. I wasn't bold enough to integrate it all at once so I declined the Pull Application Rails update and merged the functionality only. And I have to tell you — that was the point I knew it was a smart idea to keep back certain stuff due to the possible danger.


Your Task Isn't Pushing Across a Pile of Tickets

Operating as a developer is not just about running code for others. The responsible dev understands that coordination and accountability are as critical as the code itself and that while operating on the software we will really strive to recognize and interpret carefully the business interests of the customer.

Unless we all do what we're asked, we'd be like machines, when the job of a developer is to bring value to the consumer and often that could entail not performing at all. This also makes sense to often hold back— the sum of time/money/effort may not be entirely sufficient with everything you intend to introduce. There's a very good article in this link— I highly suggest reading this one entitled How I Strive to be a 0.1x developer.

It is the role of a developer to speak to the consumer regarding the design and the potential of the code/feature being developed. A developer will not only consider things as it seems right now but will still have a broader view of the effect of integrating it with the codebase.


Small Matters That Counts

When my counterpart was requested to move an application from one repository to another, I recently encountered a scenario. He found this program sending letters, but we don't use any third-party service to do so. After a short call to check that it might not be the right option and we use SendGrid to deliver our emails 5 minutes later. Why do I think it's necessary to illustrate this kind of situation? This developer found a mistake, agreed it could be changed and took the task of fixing it— the team quickly benefitted. Changing took 5 minutes, but this will serve us well for months if not years. Let's get back to the experience-I said that to demonstrate maturity, you don't have to be experienced. Often, the fact you've been given a seat doesn't imply you've had to participate directly. When you put your hand out to ask for help, someone else can step in to do some research here and there to offer your ticket — nothing inconsistent in it, so you will really enjoy having a service in applying it.


You're working with the group

 Sometimes you are not the only one to operate on a project most definitely. Also if you are the sole maker, there are many professionals around you— project managers, QAs, programmers, promotional guys — and you all work together to build a powerful community, known as the team.

A conscientious developer understands how to communicate with each part of the team, and recognizes what their responsibilities are. Therefore he/she should not be continually questioned to explain stuff, answer emails or do maintenance work. Whether this is what has to be accomplished, he/she must do their best in order to support the project going along. The dev knows that coordination and accountability are important to the project, and where appropriate, he/she discusses obstacles, threats, issues and finds support. Last and most notably, you're not going to find such a dishonest guy as that's heading completely nowhere. And "nowhere" is a location where any responsible person will like to go.

When the team has settled on regular standups-you should be confident that there is still the dev accountable. You should be confident that this individual can let you know in advance whether anything is going to happen (for example, whether he/she does not make an initial estimation or offer a sprint). The conscientious dev listens understandingly to suggestions and is responsive to improving his / her way of functioning.

Being in command of your squad involves not keeping the colleagues in the lurch as mistakes that were created by the delivery occur. It is you who have the duty to set us back on the right course.

And same goes with an incomplete job — don't leave things half completed and complete the mission before beginning a fresh one, if you want to be deemed accountable.

Then last but not least-counts the mindset. Rather of complaining and groaning and getting it much harder for the staff, the conscientious creator should not irritate quickly and searches for a solution to the issue with calm eyes.

The Take-away— What does being a good Dev mean?


What You Would Do To Be One?

Finally, here's my list of items to add to your routine: Pose specific questions.


1. Be frank and transparent.

2. Be mindful of your own limits, and do not hesitate to seek assistance.

3. Talk of the implications-NOT introducing a specified function is often safer for you. Deploy some stuff that you can accommodate.

4. Be with your colleagues there. If at the moment you may add, don't wait — do it.

5. Put the application to the check.

6. When there is a law about it, so obey it— it's for a cause there.

7. Don't believe you couldn't find a tech error. Just when to work further than to offer a "nice enough" feature.

8. Let's be optimistic.

9. Think of yourself as a regular app end customer.

So, you've had it there — s a kind of Savoir-Vivre maker. I promise that if you obey these recommendations your colleagues would appreciate that. Be a stronger maker, and even more accountable. It should not be long until everybody knows they can rely on you to cultivate a good partnership with your clients, colleagues and ventures.