Many languages need constructors (and static methods) because the class is not an object.
In Smalltalk the class is the sole instance of another class (MetaClass), so a "static method" becomes a "class-side" method. And so it is inheritable.
Primitives (as in int, double, etc.) are a different subject, and although an Integer or a Smallinteger is a specially optimized object, it has the overhead of being an object (as in "Boxed" Integer in other languages), instead of some bytes at some memory location.
Most of the times you don't need the optimized version, and if were the case that you do, then it's when you optimize that piece of execution specifically (maybe making an external call to a more low-level, optimized version).
These are commercial vendors, but there are industrial uses of Pharo itself, and as Pharo gets better a lot of companies are moving from their commercial dialects to Pharo. In particular from Cincom Smalltalk to Pharo.
The syntax is similar, and for the most part, compatible. Pharo's syntax has a few extra extensions, but nothing incompatible.
But Pharo's is inspired by Smalltalk, and I myself consider it Smalltalk, but the purpose of the detachment is to not be constrained by having to continue being Smalltalk.
E.g. in Pharo instance variables are first class objects (called "Slots").
Do you still see an advantage of using Smalltalk (like Squeak/Pharo) as a general purpose language/tool to build software or do you think that most of its original ideas were somehow "taken" by other alternatives?
Smalltalk in the 70s was "just a great thing" for its time. The pragmatic fact of also wanting to run in it real-time fast enough for dynamic media and interactions and to have it fit within the 64Kbyte (maybe a smidge more) Alto rendered it not nearly as scalable into the future in many dimensions as the original ideas intended.
We have to think about why this language is even worth mentioning today (partly I think by comparison ...)
Mmm yeah. The exploration, instant feedback and minimalist syntax are features that I wish more people would value.
I "secretly" think that Self would have achieved that too (and even better because is not constrained to the artificial abstraction of classes) but it never had a chance due to its unsuccessful IDE.
Our cognitive system converges too much to objectify things to ignore. We compulsively do that. There is something about objects that fits our cognitive system better. It's a waste if we don't take full advantage of it.
LISP machines, Solo, Edison, Oberon... quite a few systems and languages had that capability if the users and/or developers so desired. In the write-up he gave me, Kay seemed to suggest it had a unique combination of OOP support, conceptual brevity, and especially the late binding. I mean, good performance and stuff too. Those other things were considered key advantages over other systems I named.
Maybe also easier to match to hardware than LISP or FP DSL's along lines of Haskell. I'm a little out of my depth there, though. I just remember LISP machine and OS crowd having to innovate hard to fight performance issues. PreScheme & T being exceptions where low-level was easy.
Dependency Management: Yes.
Source code control: Yes (proprietary, file based/git)
Continuous Integration: Jenkins, TravisCI, TeamCity
Deployment: I'm aware of people using Docker and Ansible, and regular file copy/scp deployment.
I don't know what defines the verb "good", "flexible" and "well supported". I think they are. File based VCS is not out of the box, but is an available feature and many people are moving to that in order to use GitHub or similar services.
Dolphin is stagnated since several years. It's a beatiful piece of Software, and the best Smalltalk Dialect in terms of native Windows integration. So good integration that its low level developer (Blair McGlashan) is working at Microsoft since several years ago.
That depends a lot on your background and interests.
But if you like dynamic languages, and being highly productive with a "years ahead" development environment, then Pharo is a good alternative.
Many of the features you see added today to mainstream IDEs, have a background in Smalltalk. Even in Chrome Debugger the "code hot swap" is a showcase feature, whilst Smalltalk have it since decades.
And of course, Smalltalk provides features that no other environment/languages provides yet. So if you want to take advantage of those now, instead of waiting for them reaching mainstream, then it matters to use it now.
Features like those provided by Moose (http://moosetechnology.org/) will take years to be available as an Eclipse Plugin. :)
In Smalltalk the class is the sole instance of another class (MetaClass), so a "static method" becomes a "class-side" method. And so it is inheritable.
The meta relationship is hard to understand (at first), but it is part of what causes the parsimony in all the interactions, and the "everything is an object". https://stackoverflow.com/questions/57898036/is-it-true-that...
Primitives (as in int, double, etc.) are a different subject, and although an Integer or a Smallinteger is a specially optimized object, it has the overhead of being an object (as in "Boxed" Integer in other languages), instead of some bytes at some memory location.
Most of the times you don't need the optimized version, and if were the case that you do, then it's when you optimize that piece of execution specifically (maybe making an external call to a more low-level, optimized version).