I am compiling a list of traits or qualities that are usually found in expert developers. Everybody was a beginner - but we all learned, gained experience and developed some good qualities from these experiences. So, what according to you, are the common qualities found in top programmers?
Junior-Level: Takes a long time to get simple things done, struggles with elementary things, needs plenty of supervision, needs plenty of feedback, feels insecure about touching other people's code, keen to learn. When something goes wrong, the user using the app will usually get the blame for using the app incorrectly or "caching" will be blamed for the problem even though no caching is present, often makes n00b mistakes that will potentially take the system down in production.
Mid-Level: Self-starter and can work without supervision, elementary things no longer a problem, but struggles with more advance stuff, still keen to learn, but are less influenceable due to set ideas during Junior phase, when something goes wrong, explanations will range from spot-on to caching is the problem even when no caching is present, will go into heated debates about how things should be done even though they don't have the experience to back it up, strives to be a senior developer.
Senior-Level: Gets stuff done, tells you how it should be done due to plenty of experience, understands the bigger scheme of things and how all the system components fit together, when something goes wrong, they usually don't make assumptions and rather look at the logs to get an exact explanation for what's going wrong, will drive change when change is needed.
Architect-Level: Works directly with business to understand requirements and design the system accordingly, wants to teach how it should be done, when stuff goes wrong, the Architect has probably already fixed it before you could even figure out what was going wrong, probably does a lot less coding than the seniors and mid-level developers due to overseeing that they do things correctly, fixes code / writes code that is very complex to follow / understand which the mid-level developers will never change and the senior developers will maybe make small changes here and there since they don't understand the full scope of what they are changing. Architects can range from patient likeable people to people that will jump down your throat if you screw up.
CTO-level usually don't write any code, the best CTOs I've worked with are ex-architects who completely went to the business side. They work with the CEO to understand the direction the company is going towards in order to drive the technical business requirements after which they work very closely with the architect to put the complex parts in place so that everyone else can jump in and work on the platform.
Bad qualities in each of these groups includes, "not-my-problem" mentality, lack of enthusiasm, not willing to learn, entitlement issues, being possessive about code and not allowing other to work / change code you've written. Not taking the initiative to make things happen I consider a bad quality, but is more or less understandable when you're a junior who doesn't understand the system yet.
Good qualities in each of these groups includes team-spirit where the end-goal is placed before personal choices, issues, etc. Willingness to learn from others or to teach others. Clear communication with everyone else is definitely a good quality, documenting code properly and writing unit tests where needed and not leaving it for somebody else to do. Being a self-starter instead of waiting to be told what to do.
I concur with another poster: it would be better to use the term "developer" in this context. I also agree with Klev (Kleo Petrov, see his post) that EXPERIENCE is the most important quality. In addition to experience is the ability to learn and the ability to UNLEARN when new techniques supplant old ones (clinging to MSDOS command line programming in these days of Javascript is silly, for example). Lastly, I think it is vastly important to have the characteristic of humility and practice "egoless programming": NEVER assume that one is always right, always be open to new approaches & ideas & constructive criticism.
I find it kind of strange to separate the programmer levels by average programmer and experienced programmer, so I will call them intermediate developers and senior developers.
The answer to the question can be found in the question itself - experience. In other words - the intermediate developer can tell you several ways of doing/programming something, the senior will tell why you should or shouldn't do it that way and how that decision will affect your product. Other qualities that differentiate the senior developer from intermediate developers are leadership and mentorship - the ability to lead, manage and mentor others is a crucial aspect of the daily duties of a senior develop.
Like @Homer said, the senior developer can see the bigger picture - he can direct the priorities, roadmap, and business related to the development of your product. The intermediate developers can do the 90% of what needs to be done, but they know that the 10% can kill them.
Off the top of my head:
We have the ability to see the big picture even when working in weeds. In addition to that, we are still curious.
Bridget Sarah
Full Stack Mobile App Developer
It's an interesting one but to be honest I think the two main things that I would consider in programming would be Responsibility and Accountability. Simply because even though you are programming, you need to ensure that what you are building it will be safe.
If you've seen all that stuff about the information breaches, its due to API's not being secured correctly, leaving them exposes for any one to grab the information from. If you don't have the responsibility and accountability to ensure that someones data and business will be safe, then there's no point in programming.