What makes a language scalable ?
I believe scalability is more about system design. It sounds really odd to me, to say that one language is more scalable than the another.
Software Engineering Stack Exchange is a question and answer site for professionals, academics, and students working within the systems development life cycle. It only takes a minute to sign up.Sign up to join this community
In a nutshell, Scala has features such as operator overloading, user-defined classes, traits, and many others, that allow one to express many domain-specific problems in a very natural way.
There is no such thing as a scalable language. Every language to date fails in some regard.
Does the program support libraries written in that language?
Pascal exemplifies this problem. not scalable in this sense.
Is the language consistent?
Visual Basic is not scalable in this sense. Visual Basic is an outlier in this sense in that it consistently exhibits an utter lack of consistency. Operating overloading in C++ and other languages is a nice feature, but also a misfeature when the overload is inconsistent with the base meaning (e.g.
Is the language stable?
A program written 20 years ago in Fortran or Lisp has a good chance of being compilable and runnable today. Python and scala are not scalable in this sense. Upgrade to the latest and greatest and you may well break code that was written last week.
Is the language widely accessible?
The first computers were programmed at the bit level (ENIAC) or machine level (UNIVAC-1). Six women were capable of programming the ENIAC. Those six women have been recognized by multiple organizations for this incredible feat. A modern day large-scale complex of programs is written by people with varying levels of programming skill. A language that requires an advanced degree in computer science is not scalable. Lisp, for example, is a beautiful language that has pretty much languished in academia because it is not accessible to the masses.
Does the language support strings?
Good luck writing a parser in Fortran.
Does the language support numerical processing?
Good luck writing a scientific program in Cobol. Diehard Fortran programmers reject C (and C++, and Java, and ...) because in their minds nothing comes close to Fortran when it comes to scientific programming. For this reason, a lot of the scientific libraries provided by non-Fortran languages are simply wrappers around Fortran libraries rather than ports of the Fortran implementations to the target language.
Is the language applicable to a wide scale of problems?
The above two questions are specializations of this broader question. The original general-purpose languages, Fortran, Lisp, and Cobol. were anything but general purpose.
Does the language perform well?
Good luck writing a simulation of a galaxy in python or scala. The answer might come back when the universe ends. Performance doesn't matter, until it does matter. When it does matter, performance can be paramount. A language that shuns addressing performance issues is not scalable.
Does the language invite bad programming techniques?
Perl invites programmers to write write-only code. FORTRAN (Fortran much less so) invited programmers to write spaghetti code. Modern languages invite programmers to hide the spaghetti with constructs such as exceptions and breaks, but it's still old-style spaghetti. There's also spaghetti inheritance in C++ and Smalltalk, spaghetti call trees in languages where a ten line function is viewed as being too long. And of course holey lasagna, leaky ravioli, and a host of other kinds of bad pasta code. These misfeatures argue against scalability.
Is the language a good language for authoring legacy code?
Far too many large projects find they need to hire an ex-employee as a consultant because the original author is the only person who has even the slightest chance of understanding the code. A language that is good for authoring legacy systems is not a good choice as a scalable language.
Is the language safe?
Large systems are inevitably written by people who somehow manage to find all of the flaws in the implementation language. Project managers of a large, complex system can choose from two classes of people to author the system: Computer scientists who are clueless of the problem domain or domain experts who are clueless about how to write code well. They can't use people who can live in both worlds because such people are few in number and would destroy the company's pay scale. A scalable language has to be safe with regard to the domain and with regard to computer science constructs. Such a language does not exist.
Erlang is a good example of a scalable language. It was designed from the ground-up to support massively parallel, (soft) real-time, non-interfering threads with a clean message passing mechanism. The language eco-system was designed for near 100% uptime with in-place upgrades.
What makes a language scalable is whether or not it gets in your way when you want to move from running a single thread on a single node to multiple threads on many nodes. You can do this using any language, but the ease of which this is done differs wildly between languages.
Another example is FORTRAN. Others have knocked good ol' FORTRAN down for not being scalable, but I would argue otherwise. Given its static nature and its rigid programming model, it has been consistently used in high-performance computing situations because of the ease of parallelization. It wouldn't be the language I would pick for network programming, but if I wanted to find the eigenvalues of gargantuan matrices, it would be the go to language (pun intended).
Scalability in a language is quite different than scalability in a program. In a program it means it can use more resources according to the needs, but in a program is more about being able to extend it depending on your needs, with new types, constructions, etc...
For example Scala was designed with that in mind, to be easily extensible, and for that it gives you the right tools; if you can time you can read with more detail here
A language can be called “scalable” in the sense that it supports clean encapsulation and code modularization, is reasonably easy to read, can support the abstractions you work with and so on. Orthogonality can also help, as when you have just one way to express thoughts in the language, you can better understand other people’s code. In short, language is scalable if it gives you the right tools to comfortably build big systems.
People argue about what language features really help scalability, for example many Perl folks will tell you that orthogonality is not required for a language to be scalable. But the examples I gave should give you the idea nevertheless.