Multi-Paradigm Languages – O’Reilly


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.)

But this world has changed. Over the past two decades, we have seen the rise of multilingualism that includes both practical and direct language. Some of these languages ​​(like Scala) were of many kinds from the beginning. Some, such as Python (for switching from Python 2 to 3) or Java (for launching Lambdas in Java 8) are just imaginary or action languages ​​added. Although we think of C ++ as a language based on something, it has also become a major paradigm from the beginning. It started with C, the next language, and added the corresponding elements. Subsequently, starting with the Standard Template Library, C ++ was inspired by a number of ideas from Scheme, a native of LISP. JavaScript was also heavily influenced by the Scheme, developing the concept of anonymous functions and functions as first-class objects. And JavaScript was focused on the object from the beginning, with an object-oriented model and syntax (though not semantics) that gradually evolved into Java.

Study hard. Home deep. Look away.

We have also seen the rise of languages ​​that include flexible and flexible writing (TypeScript in the JavaScript world; add the type of type you selected in Python 3.5; Rust has fewer scripts). Writing is another part in the paradigm space. Powerful typing brings languages ​​that make the program fun and easy to create, while careful writing makes it easy to design, understand, and edit great machines. It has been easy to find people appreciating changing languages, but, except for a few years in the late 19th century, the dynamic-static paradigmatic form did not attract much attention.

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!



Source link