Geeks With Blogs
Blog Moved to http://podwysocki.codebetter.com/ Blog Moved to http://podwysocki.codebetter.com/
Part of my job is not only to design and implement solutions for my customers, but also to make my customer's developers stronger as well.  During these customer engagements, there are many times when junior developers are involved.  My job is to help those on the team to be stronger and then in turn help become leaders.

Where to start?

Well, I could start with a stack of point technology books (ASP.NET, SharePoint, BizTalk, etc) that become obsolete right during their printing, so that's not where I start.  You find that many times, the books were written during the beta phase of the product and sure enough, things change, rapidly...  But, I will mention a few that earn my admiration that form a basis for a good development background.

So, first things first, surveys are always in order to find out the comfort level with such things as:
So, as you can see, it's quite a list of things to cover.  But, no matter, we can come up with a list of things to know and teach and how to do it.

Topics to Know

When it comes to making stronger Agile Object Oriented Designers/Programmers, it's important that they know a few topics inside and out.  They can be found easily on the net and some books that I will feature later on.  Some of these include:
  • Separation of Concerns
    Breaking a program into distinct features that overlap in functionality as little as possible.  A concern is any interest or focus in a program.  Concerns are synonymous with features or behaviors.

  • Liskov Substitution Principle
    Subtypes must be substitutable for their base types

  • Law of Demeter
    A given object should assume as little as possible about the structure or properties of anything else, including its subcomponents.

  • Single Responsibility Principle
    Every object should have a single responsibility, and that all its services should be narrowly aligned with that responsibility.

  • Open/Close Principle
    Software entities should be open for extension, but closed for modification.  The entity can allows its behavior to be modified without modifying the source code.

  • Interface Segregation Principle
    Modules that encapsulate high level policy should not depend upon modules that implement details. Rather, both kinds of modules should depend upon abstractions. Abstract classes should not depend upon concrete classes and concrete classes should depend upon abstract classes.  Clients should not be forced to depend on methods that they do not use.

  • Dependency Inversion Principle
    Virtual member functions of derived classes must expect no more than the corresponding member functions of the base class; and should promise no less. It also means that virtual member functions that are present in base classes must also be present in the derived classes; and they must do useful work.
Stocking the Library

Knowing these fundamentals go a long way to making a stronger object oriented programmer.  Ok, so reading just an article or two doesn't always make things sink in.  Some books may be in order to help as well:  Let's walk through some fundamental books for solid developers.  Note that these do not include any point technologies, and instead focuses on gaining strong fundamental skills.  It's not enough to pick up an ASP.NET book, and boom, you're a solid developer.  So, let's go through some of them:
But what about technical books diving into point technologies, well, there are some of them that come highly recommended:
This by no means is an exhaustive list, but a way to get started.  By no means should they read all these books at once and should be tailored for those who need work in those related areas.  These books will get the junior developer starting to think abstractly in a more agile mindset.  But, how do you reinforce these behaviors in the development environment.  It's not enough to read a few articles, a few books and call it a day. 

Going to the next level

In order for those developers to get to that next level, paired programming is the key.  This can reinforce what they have learned in a nuturing environment and even those who are more senior programmers can still learn a thing or two.  One great way to get this kick started is to do Test Driven Development between programmers.  Have the first programmer write a unit test and have it fail.  Hand the keyboard off to the next programmer and have them make the unit test succeed.  Then work on refactoring and move onto the next.  Simple things like these go a long way.

Mentoring is also important.  Have a mentor assigned to check how the junior developer is doing with learning these new concepts.  Follow-up from the mentors is important as you track their progress.  Make time to answer questions and challenge them.

What about Agile?

Many organizations in the software development world don't work in an Agile mindset, so what are some of the ways to get there?  An Agile Coach is a great way to start an organization on the right step.  No, they aren't the Agile Police, nor should they be.  The Agile Coach brings quite a few things to an organization.  These can include:
  • Ramping an organization up on agile processes and ways of thinking
  • Experience with the Agile Process
  • An effective agent of change
  • Environment assessment
  • Being a certified Scrum Master
Holding brown bag sessions is quite important in reinforcing learned ideas and learning new things.  Of course you must make it worth people's while to attend.  These can also get the junior developers more excited and involved and people can take turns creating these sessions and presenting.

Conclusion

I hope this post gets you in the mindset of changing organizations for the better, getting junior developers to become stronger ones and creating a more dynamic atmosphere.  This of course is only the beginning on a lifetime or learning and being challenged.  Develop, mentor and inspire!

kick it on DotNetKicks.com Posted on Tuesday, January 1, 2008 7:53 PM Enterprise Architecture , Test Driven Development , ALT.NET , Domain Driven Design , Behavior Driven Development | Back to top


Comments on this post: Starting Junior Programmers on the Right Agile Track Guidance

No comments posted yet.
Your comment:
 (will show your gravatar)


Copyright © Matthew Podwysocki | Powered by: GeeksWithBlogs.net