7 ms·
Smalltalk Envy
- mwcampbell 9y agoI immediately recognized the name OTI, because I had seen it in some early articles about SWT, which is now the cross-platform UI toolkit of Eclipse. So, was SWT also originally implemented in Smalltalk? Or did it come after the transition to Java?
- igouy 9y agoYes, the SWT / Swing divergence previously existed as the IBM Smalltalk / VisualWorks Smalltalk native-widgets / emulated-widgets divergence.
- hboon 9y agoI don't know about the internals. But OTI developed Visual Age for Smalltalk and other VA for X products such VA for Java. They were all written mostly in Smalltalk, including VAJ (very interesting! It was a VM that ran both Smalltalk and Java). Eclipse was supposed to be inherited from VAJ, but having used Eclipse in its early days, I didn't see much resemblance..
- paul_h 9y agoSaid to by /u/vfclists on Proggit .. "folks should realize that ENVY was Smalltalk's Git, way before when before anyone heard of Git"
- eesmith 9y agoWhat was distinctively git-like about it that makes that connection more meaningful than "it was a version control system"? That is, what made it Smalltalk's git, and not, say, Smalltalk's CVS or ClearCase? The linked-to page suggests that ENVY used a centralized system. (Eg, "The Git model is better for distributed development" and "it had a small process that ran on a server to manage record locking".) Consider also some of the limitations in ENVY. "You would bring your changes to the machine in the form of (IIRC) a list of RCS-like versions of individual methods, then review and merge them with latest." and "What wasn’t available, was automatic merging".
- igouy 9y ago> what made it Smalltalk's git Nothing obvious. What made it more than "Smalltalk's CVS" was fine-grained method-level control of versions and configs.
- eesmith 9y agoAnd why not ClearCase, or DSEE before it? Ah, I think I understand it. I think it comes from a belief that most people treat "git" as a synecdoche or even the entirety of version control systems. The quote here uses "git" in two ways: 1) "ENVY was Smalltalk's Git" meaning "ENVY was Smalltalk's version control system", and 2) "anyone heard of Git" meaning "anyone heard of the Git system, started by Torvalds." If so, I think it does a disservice as it reinforces that wrong belief, and is confusing for those who know of other VCSes.
- smacktoward 9y agoFrom TFA it sounds like Envy was version control that people didn't find skull-crushingly painful to use, which establishes it as pretty different from CVS or ClearCase.
- eesmith 9y agoHeh-heh. After working with RCS, CVS, SCCS, SVN, and Bazaar, I find Mercurial to be a good fit for my model of how to work, while using git drives me batty. Perhaps my skull has been crushed already. :) FWIW, I and others in my group used CVS for years, after migrating from RCS. We didn't find that difficult. I didn't get a sense from the article that the people involved found RCS, ClearCase, or CVS that hard to use, only that Envy was a good fit for how they used Smalltalk.
- igouy 9y agoENVY fit how Smalltalkers used Smalltalk. Accepting a code change locally, in the usual way, created a new edition in the database. Once editions were versioned and released they would become visible to other developers, and loadable by-default.
- delish 9y agoI know so little about Smalltalk and its way of software development. A year ago, I read about VisualAge, and asked this question on the lisp subreddit: https://www.reddit.com/r/lisp/comments/4saada/curious_about_lisp_storing_code_and_state_in_image/ https://www.reddit.com/r/lisp/comments/4saada/curious_about_... It has an interesting response from lispm. Having only worked in languages where the source is stored in files, it's hard for me to get a grasp on this kind of development. I catch rare glimpses of this. Here's another example, from http://dept-info.labri.u-bordeaux.fr/~strandh/Teaching/Langages-Enchasses/Common/Strandh-Tutorial/diff-scheme.html http://dept-info.labri.u-bordeaux.fr/~strandh/Teaching/Langa... > A major problem with Scheme that does not exist in Common Lisp is that the Scheme language does not define an internal representation for programs, although to be fair, all Scheme implementations do. > For instance, in Scheme, there is a difference between: (define (f x y . (z)) ...) > which is syntactically illegal, and: (define (f x y z) ...) > which syntactically legal. (You'll probably have to read that short section "Program/data equivalence"; I couldn't find the right excerpt) Scheme code is stored in text files. Common Lisp code is a sequence of lisp objects. This is a strange difference to me; I'm an unexceptional web programmer. But it's "the very basis of the Common Lisp macro system, which uses Lisp data to represent and manipulate Lisp code." I am condemned to be intrigued!
- mikelevins 9y agoThe distinction is that Common Lisp source code is not text; it's Lisp values. What you see in a text file of "Lisp source code" isn't actually Lisp source code; it's a text serialization of Lisp source code. Other serializations are possible. As a practical matter, most of the time the distinction doesn't matter. You edit text files. Your Lisp reads the text files and the first thing it does with the contents is convert them to Lisp source code. The source code is then processed as you would expect. One place where the distinction matters is in macro processing: Lisp macro expansion operates on Lisp source code, not on text. If it operated on text, as, for example, C preprocessors do, then macro expansion would be a matter of string substitution. Instead, Lisp macro expanders operate on abstract syntax trees represented as convenient Lisp data structures, which means that macros are not limited to what can be conveniently done with simple string substitution. You have the full Lisp language available, operating on a convenient Lisp representation, to compute the expansion. More generally, when source code is represented as convenient data structures in the language, it's easier to build tools that operate on it. C compilers do not operate directly on text input; they convert it to internal data structures more convenient for the various stages of the compiler to work with. So does Lisp. The difference is that in a C compiler the representations used by the compiler are private implementation details, and in Lisp they are standard surface features of the language, available to every user.
- hodgesrm 9y agoI used Envy from 1992 to 1993 on a prototype project to replace Sybase SQL server. It impressed me deeply for two reasons. 1.) It was directly embedded in the development environment. Just saving a method would check in the change automatically and make it sharable across the team. This was at a time when most people either not using source control at all or wrestling with cumbersome systems like SCCS. Combined with Smalltalk's built-in dev environment, it is still the easiest source control system I have ever worked with, as least from the developer perspective. 2.) More interestingly, Envy also made metadata about the code base and versions of code easily accessible. Not everyone knows this now, but Smalltalk was unique in that the entire environment above the level of the VM was built in Smalltalk itself and not only available for introspection but for modification. For instance, even execution stack frames were objects that you could see and edit directly to change their behavior. (Not a good idea I soon learned.) Getting to the point, you could easily introspect every change to code and by combining introspection of classes and methods quickly determine which changes were happening where. We built a test framework that could list the changes since the last run, then compute dependencies and run an appropriate selection of test cases to check. This cut down test time by 90% or more for new changes. Because the dev environment was pure Smalltalk it was easy for us to integrate this this back into the tools so that it was available just by pressing a button. Many of the ideas of Smalltalk such as VMs, self-documenting methods and classes, and auto-compilation made their way into other languages and products. However, I have never encountered anything quite like Envy since. It displayed the same level of transcendent innovation for developer productivity that characterized the original Xerox PARC windowing system for desktops.
- diegof79 9y agoI worked using VA-Smalltalk and Envy for 3 years. One interesting thing about Envy, is that all the versioning model was available as objects that you can manipulate, and versioning was not file based but per module/class/method. In our team each developer worked on a branch, we developed an in-house tool to automatically merge all the branches. Having the class model available made easy to identify conflicts and class shape changes. The tool resolved most of the cases and also created the migration script for the object database (GemStone). Nowadays I'm working with JavaScript, using VSCode, webpack, and a long list of tools... it feels like something went wrong in the dev tooling evolution.
- pjmlp 9y agoI am fully in sync with you, having used Smalltalk/V for Windows in the university, a couple of years before Java was announced. For me in an alternative universe of ChromeOS with Dart (given Gilad Bracha's presence on the team) could have been a much better experience with a Smalltalk like OS, instead no. We still have Cincom, Squeak and Pharo though.
- needusername 9y agoIs JPMorgan still running their on fork of Envy?
- paul_h 9y agoI believe so.
- eadmund 9y ago> On the contrary, we developed a style where no branch lasted more than a day, and usually only half a day. This came about, I think, due to our direct observation of something Kent Beck taught us, which was that if something hurts, we should do it more often … If you wait a week or a month to integrate outside changes, it’s quite difficult, tedious, slow, and error-prone. When you integrate after a few hours, it goes much more easily. This strikes me as relevant to the monorepo vs. multirepo debate: having multiple repos makes it easier for things to get out of alignment, necessitating all-or-nothing hell-merges. I was also surprised by how long ago these practices I tend to think of as modern actually started. I was learning waterfall back then!