jarober
3 HN mentions · mentioned in 3 months, 2012–2017
2:50 · 1.2K views · Sep 18, 2008
A brief demo of the Smalltalk debugger, including defining a method that doesn't exist yet while the program is stopped mid-crash.
HN cites it as a concise demo of live debugging and editing code in a running Smalltalk environment.
3 comments from Hacker News
Smalltalk has a meta API that is designed to allow introspection and modification of both static and dynamic code entities [1,2]. Static entities such as classes and methods (and depending on your Smalltalk implementation namespaces and object versions) can be modified at runtime, i.e. while your program is running you can make a change and get an immediate effect. This is now known as "live" programming, however, it is notably different from your typical "hot reload" implementation in that it knows how to apply changes for individual code entities. E.g. if you modify a method you don't need to reload the entire class or module or entire runtime. For me, this feature alone makes for a big productivity increase. Dynamic entities such as stack frames can also be reified by the meta interface. This allows to inspect and modify runtime processes, e.g. inside a "debugger" [3]. Note that the debugger allows to modify and create new code while your are debugging . This is a powerful feature because it means that you get access to runtime objects inside of it. Ever wondered what object gets passed into your method at a certain point, what methods it knows, what properties it has? Just try it out and see for yourself! An interesting analogy to describe this experience: [4]. For a deeper description about the ideas behind that see Design Principles Behind Smalltalk [5]. Also, most Lisp implementations provide the same kind of meta interface, and CLOS arguably provides a more flexible a
A small example of refactoring running code is at this video And a more lengthy example of writing tests first, letting the code fail, and fixing things in the debugger: [LINK] This is kind of like writing code that doesn't exist or doesn't work, and letting the type checker guide you through the things you need to fill in. The difference is that Smalltalk is actually executing your code, so you can see actual values rather than just type errors, and it will keep trying to execute your code while you change things. It might be possible to do something like that with static typing, but I think the real issue is that most advocates of static typing wouldn't really _want_ to mess around with programs in inconsistent states in the first place.
This may have been posted in 2008, but the tech it is demoing was decades (yes, plural) old by then: this video This video is a simple demonstration of very mature tech, not a demo of something hot and new. That's a demo of a Smalltalk environment with the programmer deliberately writing some code that crashes, going into the debugger, adding the method on the fly, and then having the original method call complete despite the method not yet having existed. It isn't quite true that there is nothing new under the tech sun... but there's certainly less new than most people seem to think.