Hello All,

I have a question more like suggestions but none the less. For the past few days I've been thinking what "skill sets" not too sure what the proper word would be.

Ok more to the point.

I just what to know what things a programmer would need to know to be considerd that type of programmer.

Beginner/Novice:
Some description of what skills a programmer would be....

Average/Intermediate:
Some more descriptions

Experienced:
More descriptions

Expert:
Further descriptions

I just what to know for example what namespaces each skill set would be contained or what projects a person of that skill could complete.

I hope this is descriptive enough for someone to understand.

Anyways Thanks in advance.

I think that is quite large question. I will only try to answer a portion of it.
I can tell you that programming in C#, consists of several basic skillsets.
General Computer Science Skills - Understanding Basic Computer Functionality e.g. Memory, Heap, Storage
Languages Skills - This is basically the syntax that makes up the language. C# 3.x has evolved significantly since its 1.x days with the addition of generics, lambdas, and linq. So there is much to learn here. It will be enhanced even further when 4.0 arrives.
There is also .Net framework skills - The .net framework is quite rich and learning how to use many of it's components is a craft in itself. To be considered a non-novice you need to learn the different areas of the framework such as WCF, WPF, etc. You also need to master the basics elements such as generics, delegates, interfaces, etc.
Advanced Programming Concepts consist more of things like design patterns, good coding practices, principle driven design. Design patterns can be applied no matter what language you are using. Design patterns are, in my opinion, what separate beginners from experienced. Using design patterns effectively where needed are what will help you solve problems that others have already solved elegantly. In addition to design patterns you must also strive to master the craft of programming by create not only funcional apps but functional apps that are maintainable.

It all depends. You could be an expert in database programming and an absolute beginner when it comes to designing and developing a game and vice versa.

Beginner/Novice:
Lacking most of the things mentioned below.

Average/Intermediate:
Inexperienced in the things mentioned below.

Experienced at programming:

  • able to make the most of the type system he's working with
  • thinks about API design in terms of how to minimize the amount of mistakes made while using the API (and able to take advantage of the type system for that purpose)
  • able to stop worrying and write some gosh-darned code
  • awareness of the homomorphisms in his program.
  • able to design his own algorithms and data structures
  • doesn't do stupid stuff like silently ignoring errors and adapting around them -- see the bullet point on API design

Expert:
A silly notion.

On design patterns: Learning design patterns separates beginners who have heard of design patterns from beginners who have not. Learning several design patterns is like learning several chord progressions -- it doesn't make you a good composer, or a composer at all. Knowing some design patterns doesn't make you good at making the most of your type system. Knowing some theorems doesn't make you a good mathematician.

Some popular design patterns are basically harmful and most classification systems are unnecessarily fine-grained. There are some tricks useful to know for my first two bullet points, especially the first. That's all design patterns are. I'd rather refer to the knowledge of several design patterns as "experienced with the Tricks and Ways of Doing Things." If that's what it was called, people wouldn't treat it like a checkpoint on a list of things to learn. For example, stuff like adding to the end of an enum definition a value whose integer value is the number of things in the enum is a useful trick the same way that the visitor pattern is a particularly useful trick (especially nice, in C#, is the kind that takes n delegates directly instead of the kind that takes an object with n methods). Stuff like returning a bool and using an out parameter that never gets assigned null, rather than using null as a special sentinel value (which somebody could forget to check), is another such trick. Is that a design pattern? Or are design patterns just the subset of tricks that have to do with how classes relate to one another? Anyway, I think we should look more broadly than design patterns.

On algorithms and data structures: The same analogy to chord progressions applies here.

On API design: In particular, knowing and understanding the value of immutability, and how to design immutable types, is important and a very neglected skill.

The scope of this comment: I'm only writing about the aspects of programming (you could say, the set of things that apply to cowboy coders) and not other parts of software development that revolve around it.

It impossible to call anyone a professional programmer. May be one in a million.

When it comes to programming, you should analyze the logic behind the program that you want to make. Languages are just tools. Its the skills of the programmer that matters. You can do wonders with just the basics known. When you get to an expert level, you will probably notice that the things you had done before are too simple.

You can call yourself an expert only when you have the skills and experience

>You also need to master the basics elements
>such as generics, delegates, interfaces, etc.

I'm a fan of generics, but I don't delude myself into thinking that they're required knowledge. You can get by without writing a single generic class or method and still be an non-novice. Laundry lists of "learn this or you're a n00b13" are quite pointless. The difference between a beginner, a non-beginner, and an expert is much like the difference between bad code and good code. You know it when you see it, but there's not a perfect methodology for sniffing it out.

>Design patterns are, in my opinion, what separate beginners from experienced.
I agree thoroughly. Beginners use design patterns because they lack design experience. Experienced programmers don't need them because they have the requisite experience.

>It impossible to call anyone a professional programmer. May be one in a million.
Erm, not really. A professional programmer is a programmer that gets paid to program. That's the primary definition of "professional". If by "professional" you mean "guru", then I'd agree. Gurus are a myth.

>You can call yourself an expert only when you have the skills and experience
You can call yourself an expert only when a large enough sampling of your peers call you an expert.

I would like to add this is an odd inquiry.

a Beginner would simply be anyone, who has written any code at all, with intention of continuing to learn.

Intermediate would be someone who can write and finish a simple application from scratch with only a reference book, or web search for assistance, or a complicated application with only a moderate amount of questions and direct assistance.

experienced, even more simple, If you are accustomed to the syntax, understand the base classes, are comfortable with the compiling tools that you use, and that you have written complete applications that are usefull with a good error handling.

and as for expert, its just a sillly word, It means one who has special skill or knoledge in a particular field. so generally speaking, if you know something about the language that most other programmers don't (immediate beginners excluded) you are technically an expert.

but it doesn't matter what category you are in, any one here can learn something from anyone else. That is the benefit of a forum. were people from different skill levels can come together and share their knowledge, everyone sees a problem differently. and comes up on different solutions. That the reason why each country has its own language. thats the reason there are so many reply's to this post. I don't think its something to worry yourself bout, the only pratical application of this information is building a tutorials website where the tutorials are arranged based on their difficulty.

DiamondDrake.

It impossible to call anyone a professional programmer. May be one in a million.

If programming is your profession then I'd say you could quite confidently call yourself a professional programmer.

Another skill that is required - probably at the intermediate level - is the knowledge of how the compiler and linker work for your particulare platform. In the case of .Net knowing how the CLI works is also important.

As Diamonddrake pointed out, for an Expert you are likely to be an expert in a particular field of programming - be that realtime, database, 3D, etc... - in much the same way as you cannot really be an expert in construction, though you could be an expert in say contructing bridges or roads or tunnels, etc...

Thanks for the advice and its good stuff! Anyways I wont mark the post solved as it's generally based upon opinion, and to allow others a chance to offer their opinion as well. Thanks!

This article has been dead for over six months. Start a new discussion instead.