Question over here is are design patterns specific to a programming language or technology,
Like you can do composite pattern only in C#,Java but not in VB6.0.Is that true, If yes that what are pattern that can't be implemented with out object oriented programming languages.
I think that it depends more on what language features are available to you, but no, I wouldn't say that design patterns are constrained to particular languages.
Patterns depend on programming languages, although not so strongly as your question suggests. For example, Iterator is a design pattern, however in many languages (C++, Java, C#) it is part of the language (OK, the class library).
There are several patterns which can be called Object Oriented, i.e. it is difficult to implement them without proper classes, inheritance and polymorphism. Examples: Abstract Factory, Strategy, Template Method. However, even these could be done in e.g. C, if someone really wanted. This is possible because C has function pointers. I would be very hard pressed though to imagine an implementation of the above patterns in a non OO language without pointer (or equivalent) support. Then again, I guess these patterns wouldn't really make sense in such a language anyway...
Most of the patterns are language independent. For some patterns and languages major hackery is needed. For example windows COM is a bizarre implementation of composite pattern in C (not C++) language.
Some languages like VB 6.0 put up major hurdles that need to be jumped over to implement some patterns, thus making it not worth the effort.
Yes and no. Certain design patterns are not specific to particular languages, but there may be design patterns specific to classes of languages.
For example, there may be functional design patterns that are specific to functional languages or object oriented design patterns specific to object oriented languages. Some overlap may exist, but it is not 100%.
Design patterns are not language specific per se, however some patterns can be paradigm specific, for example implementing a singleton pattern in C makes no sense as you might as well just write a plain old module.
However design patterns are not language specific but can be more useful or make more sense in different paradigms (OO vs structured vs functional)
This is to give a straightforward answer.
On one side some patterns are language dependent, patterns like Factory, Strategy and Template rely on language mechanisms like polymorphism and inheritance.
On the other hand some patterns exist because language we use doesn't have the right functionality (example: Visitor pattern is used to make up for the lack of double dispatch in languages like Java and C++).
Among the classic 'Gang of Four' patterns, quite a few are language-specific. Others, like Visitor, are really useful only in an object-oriented setting. Functional language have fold (catamorphisms) instead of Visitor, and anybody trying to use Visitor in a functional language would be viewed as a dangerous lunatic. Finally, there are patterns that could be applied in any language, like Factory.
One of the reasons I'm not a big fan of the patterns movement as practiced by Gamma et al is that the view of pattern lacks intellectual coherence. "Anything useful" is a nice claim, but doesn't, as you observe, give much guidance as to which patterns might still be useful when language or paradigm changes.
For a illustration of the risks inherent in classifying patterns, check out one of my favorite collections: Kent Beck's Smalltalk Best Practice Patterns. Despite the work "Smalltalk" in the title, many programmers have found these patterns applicable to languages like Java and Python as well.
Design patterns are not inherently language specific, although some patterns are more useful in some languages than others.