@mkwayisi Programming is one of the activities performed during software development. Which means programming is part of software development.

Programming is fun, but developing quality software is hard. I have come across quite a few programmers who are more interested in learning as many languages as they can to the detriment of learning good design techniques and development practices. While it is good for us as developers to learn as many languages as we can, it is also crucial for us realize that learning languages alone is not enough we must also devote as much time to learning the techniques, tools and practices of the trade.

DI is the antidote for highly-coupled code.

@kobojunkie Why not i will be happy to help put together some UML documents. I think is very important for developers/aspiring developers to properly understand UML syntax and semantics.

@ekt bear Like i said earlier DI promotes loose coupling here is a small example of constructor DI using c#:

Interface ISomeInterface{

void SomeMethod(); }

Public Class SomeClass{

Private ISomeInterface _somefield;

Public SomeClass(ISomeInterface somefield){
this._somefield = somefield;}
}

As u can see from the small example above the dependency for SomeClass is injected from outside SomeClass via its constructor. Hope this helps.

@ekt bear I have not provided any concrete example because i wanted to discuss DI from a language agnostic standpoint. You can always google around for concrete examples of DI in your preferred language.

Spring is good but there are others for java which i think are equally very good like pico container and google-guice.

In designing an object-oriented application, a major tenet of design is "loose coupling". Loose coupling means that objects should only have as many dependencies as is needed to do their job - and the dependencies should be few. Furthermore, an object's dependencies should be on interfaces and not on "concrete" objects, when possible. Loose coupling promotes greater reusability, easier maintainability, it also enhances unit testability by allowing you to easily provide "mock" objects in place of expensive services, such as a socket-communicator."Dependency Injection" (DI), also known as "Inversion of Control" (IoC), can be used as a technique for encouraging this loose coupling. There are two primary approaches to implementing DI: constructor injection and setter injection. Obviously, at some point, something must be responsible for creating the concrete objects that will be injected into another object. The injector can be a parent object, or can be externalized and handled by a "DI container" framework. There are scores of open source DI container framework such as castle windsor, microsoft unity, ninject to name a few. DI is worth giving a shot if you are serious about developing loosely coupled applications.

I use sharpdevelop for .Net, eclipse for java and devc++ for c++

I like to read code because code is good to read. Its a fun and educational experience where you learn a lot about programming, algorithms, idioms and a host of other things. You even learn how to lay code out nicely.

Unit testing can also be called developer test because it is test performed by developers for developers. As a developer if i want to find out how an application should work i usually find it more useful to read the various unit tests of the application than the requirements document unless of course the application does not have unit tests.

The only reasonable and sensible way to share the work of writing unit tests and writing production code between two different developers i think is through peer programming

The System.Contract type in .Net framework 4.0 consists of static methods that enable developers to implement code contracts (preconditions, postconditions and invariants).

@ekt bear TDD does require that you write all your test up front before writing code it should be done iteratively along with coding and refactoring the disadvantage of writing tests up front is that requirements can change mid way through the project.

@ekt bear I honestly do not see how you can separate unit testing of a module about to be developed from the developer of the module. In fact TDD encourages this unit testing and developer tight coupling by advocating the test > code > refactor iterative development process.

@ekt bear Unit testing is developer-centric in nature which means it is the responsibility of the developers to write unit tests. Except of course you are talking about functional and acceptance tests.

@kobojunkie Be specific are u currently working on a project that requires that u write unit tests or u just want to learn how to write unit tests.

@kodewrita I have just recently started reading RhinoMocks source code. RhinoMocks is an open source library/framework written in c#. It is used for creating dynamic mock and stub objects which are used to aid unit testing of software modules.

Reading other people's code is one of the best ways to improve yourself as a programmer. Code reading is a very much under appreciated aspect of software development. Believe me when i say this i have learnt a lot from reading other people's code. As developers we tend to focus our time, energy and resources on how best to write code without giving much thought about how best to read code i strongly believe that code reading is as important a skill as code writing. According to Dave Thomas of the pragmatic programmers the average software developer spends about 40% of the time writing code and 60% reading it.

I am test infected and i just cannot see myself working without tests anymore. It has become a norm for me as a developer.

UML which stands for unified modeling language is often defined in as a language for visualizing, specifying and documenting the artifacts of software systems. It is therefore imperative for software developers and architects to have a proper understanding of both the syntax and semantics of the language as well as its application. UML provides a means for developers to exchange design ideas among each other rather than in code. The disadvantage of representing design ideas in code is that today's programming languages cannot express architecture. UML being a visual language by nature provides an avenue for developers to visualize the structure of the application they are trying to build. Also UML is critical to learning and understanding design patterns.

Are there any developers on nairaland that do automated unit testing using any of the xunit flavors. As a developer myself i believe that writing unit tests is as important as writing production code. Test driven development (TDD) which is an important XP discipline (extreme programming) advocates writing test before any line of production code is written. I must admit TDD is a difficult discipline to follow and master and writing unit tests can be daunting and time consuming at first but that should not deter you from unit testing your code. Testing gives confidence to you as a developer that your software behaves as it should.