The IDE keeps the text files, and that's what your source code is made of. Go to any Smalltalk github project and you will find .st files, which are plain text files, and there's your code.
I'm a Lisper, i do know what Image-based development is, because that's what I use*
You're misunderstanding Smalltalk, probably because of hype mongers like the author of this article. Source is text files as usual. This is not the same as the image. Your environment, and the compiled classes, are contained in the image, but the IDE also keeps the source, text files.
>St files by the way are a serialization format, they are not meant to be hand editable and are not treated as such and contain all kinds
.st __source__ files are text files. You are confusing them with the image files.
No I'm not misunderstanding Smalltalk, that Smalltalk now has a git plugin to be able to expose itself in that manner is exactly the kind of jumping through hoops I was referring to, it's taken many years for that to become stable and most of us still don't use it, we use Monticello. And both of those are for sharing code, not for developing, we don't work on those st files, we export them.
Don't tell me what I'm thinking and because of who, I make my living with Smalltalk (Squeak and now Pharo) and have for well over a decade and have done hundreds of millions in revenue through my Smalltalk apps.
> .st source files are text files.
I didn't say they weren't, they're still a plain text serialization format that is not directly what Smalltalk looks like and we still don't work on code by editing those files.
> You are confusing them with the image files.
No I'm not, if you actually read what I wrote, you'd see that.
Lisp is not Smalltalk, do not confuse how Lisp does image based development with how Smalltalk does it; they are not the same. When you have a few years experience actually working with Smalltalk doing production level stuff, then come talk to me, right now you're repeating nonsense that you're inferring based on apparently some light reading and no actual experience in the culture of and use of an actual Smalltalk.
Smalltalk's image file(s) contain only the compiled code, not the original source code, which is on the changes and source files. You could decompile the image and get most of the source but not in its original, complete form.
If your image crashes it gets reconstructed from those two files.
It would be great if you Smalltalk fans would explain its source handling in these terms above, instead of promoting "image based" as some sort of magic where there aren't any text files, because in this forum some programmers are getting (needlessly) scared about the image-based system and (needlessly) fearing it.
I'm sorry but you are really completely missing the point. You are conflating how Smalltalk is implemented under the hood (using files) with how Smalltalk is used for programming (using the image). Under the hood, Smalltalk has to adapt to the host platform, whether that be Windows, macOS, or Linux. In the original Smalltalk implementation over four decades ago, Smalltalk was the host platform (or operating system), so there were no files for source code.
Correct - and the only time someone would directly interact with the .changes or .sources text files (as-text-files without using the IDE), is in the unlikely event that the image file had become corrupted in some way, and they were trying to recover work that had been done.
The .changes and .sources text files are maintained in-the-background by the IDE and kept in-sync with the image file.
You only threw attacks and condescending comments instead of explaining Smalltalk's IDE way of keeping files, which I did. You are doing a disservice to the Smalltalk community with such an attitude.
> You're misunderstanding Smalltalk, probably because of hype mongers like the author of this article.
With that comment, you lost any good will I had for you. Despite that, I tried to explain to you anyway what we mean by file based and you simply ignored it and chose to argue with me about st files being plain text which is entirely irrelevant to the conversation. What more do you want? You're wrong, Smalltalk isn't file based, but you don't seem to know what Smalltalk'ers mean by that term, and you refuse to admit you're wrong despite you not even being a Smalltalker. That's willful ignorance, I have no patience for willful ignorance nor do I have any duty to the Smalltalk community, something I know vastly more about than you as I've been a member of it for a very very long time.
Getting off topic you mentioned doing production work in Smalltalk for a decade and even said "hundreds of millions" in reveue. To me that is quite impressive. Any chance you can point to a project you've done or some prominent Smalltalk apps? Pharo has some minor ones on their site and the author of the article frequently mentions JWARS. I'd like to see more though.
The projects I'm talking about are closed source business apps. My app is listed on the Seaside.st success stories page, but I'd rather not talk about it here.
I'm a Lisper, i do know what Image-based development is, because that's what I use*
You're misunderstanding Smalltalk, probably because of hype mongers like the author of this article. Source is text files as usual. This is not the same as the image. Your environment, and the compiled classes, are contained in the image, but the IDE also keeps the source, text files.
>St files by the way are a serialization format, they are not meant to be hand editable and are not treated as such and contain all kinds
.st __source__ files are text files. You are confusing them with the image files.