Contents:
- Why I write and who you are
- Haskell - The language of terms
- Haskell - The language of types
- Haskell - Typeclasses
- Parser combinators: Fast streaming of huge and complex files
- Multiple sequence alignment: Algorithms and performance
- Command line scripting: IO, system calls and parallelism
- Rogue: Graphics and concurrency
- Alignment dashboard: REST APIs and web design
- The End
The programming world is trending towards more functional and more strongly typed languages.
What about object oriented languages? They were hyped as THE way to program for years. Even traditionally functional languages like List and Haskell tried to adopt (or at least support) OOP models in the 1990s and 2000s. C++ was developed from C to fit with the hyped OOP paradigm. Java, of course, with their strong advertising campaign, did much to shift the enterprise programming towards the OOP paradigm. The dynamics of the OOP paradigm follow the hype cycle described by XXX [cite]. It appeared, rose to crazy heights were it was applied to every possible problem, then the community learned it wasn’t perfect, and it fell to occupy the niches where it is most suitable. The niche for OOP languages seems to be in describing agent systems, where many objects interact. This could be a website, where programmatic objects represent buttons, windows, and widgets. Or it could be a game or modeling environment where objects are then environment, entities in the environment, and sub-entities such as limbs.
[[add picture from blender]]
The dynamic languages, such as Python currently, also follow a hype cycle. For awhile, they were applied to everything. Types were felt to be too restrictive. But currently dynamic languages are adapting by adding gradual type systems (e.g., MyPy in Python) or by being superset by typed languages (e.g., javascript by typescript).
So what of strongly typed functional languages? They are currently on the ascent. Assuming that they will also follow a hype cycle, then they will gradually become the hottest way to program, be applied to everything, and then recede to their niche as well. And what will this niche be? I think they will occupy all the space that are not extreme low-level code, high-level UI design, or short scripts and domain-specific languages.
And what will be the main STFL language? Rust may be the goto performance language for several decades. A strongly-typed variant of Python may become the default for responsible general development. It would be compatible with vanilla Python, which will likely continue to be used as a light scripting language that wraps functions developed in more rigorous languages. However, I believe the real winner has not been created yet. It can’t be. Language research is still a hot area of research. New ideas are constantly being discovered and tested.
There will always be demand for a language with a shallow learning curve. But this language needn’t be weakly-typed. A language can be strongly-typed but require no type annotations. Such a language would depend on complete type inference. It could be safe and raise useful static error messages that guide the programmer. It could wrap functions written in high-performance languages.
Scripting language - This would be a lingua franca. Maybe a variant of Python with complete type inference.
Thinking language - Haskell but without the warts
Correct language - Possibly the same as the thinking language, but it may sacrifice elegance for rigor
Machine language - The syntax for this language should make the operation of the machine obvious and unambiguous. Typechecking should consider the machine architecture. This may also serve as an intermediate language that is the higher languages compile into.
Domain Specific Languages - Want a pretty syntax for specifying the object hierarchies in your UI? Or a mathematics language where all variables are vectors? Or a logic language?
Lovecraftian languages - Could there be utterly alien languages? Future quantum languages may fall into this category. There could be languages that generalize function. But these tend to be systems described by differential equations that can themselves be specified and run within conventional languages. Agent based systems, as well, can be specified and run.
But what else is there? Is functional programming the ultimate thing? Is this the end? Are there other paradigms that may rise to challenge it? Quite possibly. One vanishingly obscure alternative is pattern-based programming [cite]. Perhaps that will be the final technology?
There will also be demand for highly correct languages. These are what should be used to implement anything important. All mission critical systems. All scientific algorithms.
There will always be demand for languages that allow easy reasoning about performance. This language will differ syntactically from the ideal language for expressing thought.