Source code control: Yep. There's a slow transition from Monticello to Git but tools are still subpar. Trying to integrate thing that are not Smalltalk code into monticello is a pain.
Continuous integration: Yep. Everything is doable from the command line. The Pharo guys actually build everything with Jenkins (https://ci.inria.fr/pharo/).
Deployment: I use ansible to provision my server and to deploy webapps. Nothing really fancy (https://github.com/fstephany/hello-pharo/).
My everyday job involves Ruby+Rails, Objective-C and Android development.
Programming in Pharo Smalltalk feels much better than any of those but in the end of the day, those tools get us faster at the results our clients want (usually some kind of mobile app with a backend).
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.
Or so I remember as of the early '80s.
For example I used to save a minimal site-configured incremental image with some OS patches first. From there I would load the software I use and dump the next incremental image. Into this image I would load more software and the stuff under development and make another incremental image. Based on this I would load additional patches as necessary...
The reason why these images were saved is not startup time. The reason was that loading code (-> applications) was quite slow on most Symbolics Lisp Machines during the 80s.
If you develop on a Symbolics Lisp Machine it first looks into the running image for many types of information, not the file system: documentation strings, arguments, who calls, ... even the documentation database needs its index to be loaded into the image.
These tend to be challenges, or at least sources of complaint, for image based development environments like Smalltalk and Lisp.
Have modern Smalltalks successfully addressed these issues? Even if Smalltalk has its own tools to address some of these, are they as good, as flexible, and as well supported as the tools available to work with plain text source files?