The programming world was divided into functional languages, visual languages, and everything else (especially system languages). One “was” a working programmer (at least as a hobby) writing for Lisp, Haskell, or Erlang; or someone “was” an OO programmer (mostly technically), writing codes in Java or C ++. (No one has ever called himself a “programmer”; when these names ran out of education in the 1990s, calling yourself a “programmer” is like wearing big ties and bell jeans.)
Why do we still see sacred battles between active and established programmers? That sees me as a great opportunity to miss. What would “multi-paradigm programming” mean? What would it be like to deny hygiene by using any type of material that offers the best possible solution to any situation? The most important programs are so many that they have sections where the paradigm focused on the object is clear, as well as the sections where the active paradigm is best. For example, look at “works” as repetitions. There are algorithms that sound over and over again (Hanoi Towers, or print binary option); there are algorithms that do not make much difference whether you use loops or repetitions (each time tail extension will work); and there are times when repetition is slow and memorable. How many programmers know which method is best for any situation?
These are the questions we need to ask. Design has been linked to software applications from the beginning. What kinds of designs are heard in a multicultural world? Keep in mind that the design is “not made”; are seen, and solutions to problems that appear over and over again, and this should be part of your list. It is unfortunate that working developers tend not to talk about design; when you realize that systems are perceived as responsive, words like “systems are not required in working languages” cease to make sense. Software developers solve problems, and they also see the same responses appear over and over again. We should not expect problems and answers to be the same problems and solutions that OO developers see. Which brands offer the best of both types? What strategies can help you determine which method is most appropriate for some situations?
Software programming languages represent complex thought processes. Over the years, paradigms have multiplied, along with the problems we want to solve. We are now talking about event-driven programs, and many software programs are driven by events, especially in the future. Metaprogramming became popular with JUnit, the first widely used tool to rely on this feature which is often associated with working languages; since then, several very different types of metaprogramming have made it possible in Java, Ruby, and other languages.
We have never solved the problem of how to create paradigms to play well together; to date, languages that support multiple paradigms have been left to programmers to figure out how to use them. But just mixing ad hoc paradigms is probably not the best way to make great machines — and now we are developing programs in measurements and speeds that were not difficult to imagine a few years ago. Our equipment has improved; now we need to learn to use them well. And that will include combining paradigms that we have long seen as different, or even conflicting.
Thanks to Kevlin Henney for the thoughts and ideas!