DOCSLIB.ORG

The Best of Comp.Lang.Smalltalk: Two New Smalltalks

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
The Best of Comp.Lang.Smalltalk: Two New Smalltalks The Best of comp.lang.smalltalk Alan Knight Two New Smalltalks malltalk is a very loose term. While there are some still won’t run as quickly as compiled code (you have to clear, defining characteristics, there are also many spend CPU cycles to translate, and you can’t afford to think Svariations as well. This is important because software too hard about optimization). Finally, it requires a VM to development is a large field, with different solutions do the translating, which makes it more difficult to create appropriate to different problems. This article will discuss standalone executables, DLLs, and callback functions. some of these possible variations, with reference to two Smalltalk MT is fully compiled, and has “an optimizing promising new implementations. compiler that generates fast, compact code.” Full compi- The first of these new implementations is Object lation should give significantly better performance than Connect’s “Smalltalk MT,” a high-performance imple- existing implementations, and the absence of a VM allows mentation for Windows NT 4.0, with full compilation and simple programs to be very small indeed. MT claims to be true multithreading. The second is Intuitive Systems’ able to make DLLs (which, to my knowledge, no existing “Dolphin Smalltalk,” which boasts a low cost and a very Smalltalk can do), and to fit a trivial windows application low memory footprint. into a 100K executable (their runtime-support DLL adds Neither one has been officially released yet, but free only 52K). prerelease copies are available for download from their Dolphin Smalltalk is bytecode interpreted. I would Web sites (see contact information at the end). Even if expect this to offer significantly slower performance than you’ve missed the free periods, both companies are aiming current implementations, but with much lower space at product prices in the low hundreds (of U.S.) dollars. consumption, even for significant-sized applications. The Note that I looked at prerelease versions, and that I’ve company states that it “will be producing an optional JIT only played with them, so all I can do is relay first impres- in future.” When space is more important than speed, this sions and generalities about their implementation choic- is a very reasonable option, and this is often true in es. I hope you’ll see a full review in these pages once they applets. The firm also says it will shortly have its VM are officially released. encapsulated as an ActiveX downloadable. COMPILATION SIZE Most current Smalltalks use dynamic compilation, now Both companies advertise their ability to make very small commonly referred to as Just-In-Time (JIT) compilation. executables. Traditionally this has been a weak area for This is an example of a process I call “cross-domain buzz- Smalltalk. In many of the application areas for which word hybridization.” In this process, a recognized buzz- Smalltalk is used, one can argue that size doesn’t matter as word from one domain crosses over to another, where it long as it does the job. But with the growing importance of attaches to a concept almost, but not quite, entirely small applets over monolithic applications, size is becom- unlike the original. If you don’t like it, think of it as pay- ing more significant. back for the term “object-oriented.” Dolphin’s approach to minimizing size uses bytecod- In dynamic compilation, the methods are stored in ing and a very small interpreter (I counted 155K including bytecode form. At runtime, some (or all) of these byte- all the DLLs) with a relatively standard (but small) image. codes are translated into machine code. This can provide Their prerelease packaging support wasn’t very sophisti- most of the speed of machine code with a much smaller cated, but when a development image starts at only 1.4 executable size, comparable to that of bytecodes. MB a good stripper is more of a luxury. Although this is a good approach, it’s not a perfect solu- Smalltalk MT can provide extremely small sizes for tion for every circumstance. It takes more space than byte- simple programs, but for larger programs the space cost codes (you now have to store both compiled forms) and of full compilation becomes significant. The firm tries to combat this through modular class libraries and a mini- Alan Knight is a Smalltalk guru with The Object People. He can be malist framework. reached by email as [email protected], or at 613. 225. 8812. The typical Smalltalk programmer doesn’t think too 22 http://www.sigs.com The Smalltalk Report much before using something that’s in the development THREADS image. This is nice for development but bad for packag- One of the most innovative features of Smalltalk MT is its ing. Everything depends on everything else, and all you full support for operating system threads (“true” multi- can do is remove the compiler and development tools. threading). Making a decent compiler isn’t that hard, but MT claims to have kept the base classes small and mod- there are many issues involved in making Smalltalk use ular, so if you don’t use a particular class or subsystem it OS threads. The only other implementation I know of is can easily be removed. They also claim to have a sophis- OTI’s embedded systems implementation, and it only ticated packager, though I’m skeptical. Packaging is a dif- supports threads for real-time operating systems. ficult problem. I figure their base image, including the I believe OS threads are often given too much impor- compiler and development DLLs, is 1.3 MB. “Image gen- tance. For 90% of applications, the standard Smalltalk eration is largely automatic. An Image Builder com- process model will suffice, along with the ability to make putes the set of referenced classes and methods, start- system calls without blocking. The critical issue is that ing with the image-entry point.” when one Smalltalk process waits on a system service, the MT has also minimized the size of the runtime by stick- entire Smalltalk system should not wait. Given this capa- ing very close to the OS functionality. bility, which most implementations provide, it’s not diffi- “All GUI and operating system-related classes present cult to render demanding applications like Web or termi- a Win32-like protocol. This ensures that applications nal servers, and you don’t have to deal with the addition- run with minimum overhead on the Windows family of al complexities of OS threads. With the Smalltalk model operating systems, and leverage you can even have thread-manipu- on existing know-how.” Smalltalk is a very loose term. lating code that’s portable between operating systems. FRAMEWORKS While there are some clear, That’s a very good solution when it A Win32-like protocol for window- defining characteristics, there works, but there are times when you ing is definitely a two-edged feature. really need OS threads. One example is It makes Windows programmers are also many variations as symmetric multiprocessing (SMP). who have programmed in other well. Operating systems that support multi- languages feel right at home, and it ple CPUs in one machine can map OS minimizes the amount of code you need to map a threads to different processors, but not Smalltalk processes. Smalltalk framework onto the operating system. I think Presently, this affects only very high-end machines, but it will there’s no question that this reduces the amount of code in become more and more important in the future. the image. Given that there are lots of implementations out there On the other hand, frameworks that are written with with the standard threading model, the choice of using OS C or C++ in mind look really ugly compared to those threads in Smalltalk MT is a very welcome one indeed. designed for Smalltalk. Look at Visual Smalltalk vs. IBM. Visual Smalltalk has tight integration with Windows, to PLATFORMS AND PRICE the point where you can implement your own wm:what- By now I ‘ll bet you are impatient to get your own copy of ever: messages, but provides a very clean, simple, either or both of these implementations for your favorite Smalltalk-like framework above that. IBM has its platform. Unless you’re a Microsoft fan you’re out of luck. X/Motif layer, which translates into calls to the real OS. It Both of these implementations have opted away from works very well, and it’s extremely portable, but it’s way portability in favor of close integration with Win32. In fact, too close to C programming for my taste. IBM’s saving the first version of Smalltalk MT runs only on Windows NT grace is that with VisualAge or WindowBuilder you rarely 4.0 due to problems with Win95’s threads, but they expect have to descend to that level. Smalltalk MT doesn’t to have a Windows 95 version soon . appear to have a GUI builder. On the other hand, I’m Dolphin Smalltalk has gotten more attention on the sure there are lots of people using C/C++ for whom a Net, because it can also run on older versions of NT and Win32-like framework in Smalltalk (especially a Windows 95. Don’t expect them to expand their list of Smalltalk that can produce fast, compact executables) platforms too much. In response to a number of calls for would be a big step up. an OS/2 version, Andy Bower of Dolphin’s support group Dolphin Smalltalk, in contrast, uses MVC. This is the ([email protected]) wrote: oldest and best known of the Smalltalk frameworks, and “The initial design aims for Dolphin were firmly has been passed down from PARC into VisualWorks.
Load more

Recommended publications
  • Hopscotch: Towards User Interface Composition Vassili Bykov Cadence Design Systems, 2655 Seely Ave, San Jose, CA 95134
    Hopscotch: Towards User Interface Composition Vassili Bykov Cadence Design Systems, 2655 Seely Ave, San Jose, CA 95134 Abstract Hopscotch is the application framework and development environment of Newspeak, a new programming language and platform inspired by Smalltalk, Self and Beta. Hopscotch avoids a number of design limitations and shortcomings of traditional UIs and UI frameworks by favoring an interaction model and implementing a framework architecture that enable composition of interfaces. This paper discusses the deficiencies of the traditional approach, provides an overview of the Hopscotch alternative and analyses how it improves upon the status quo. 1. Introduction Hopscotch are attributable to its revised interaction and navigation model as much as to the underlying Newspeak [1] is a programming language and framework architecture. For this reason, this paper platform being developed by a team led by Gilad pays equal attention to the compositional frame- Bracha at Cadence Design Systems, Inc. The sys- work architecture and to the changes in the inter- tem is currently hosted inside Squeak [2], a descen- action model of Hopscotch compared to more tradi- dent of Smalltalk-80 [3]. Smalltalk, along with Self tional development environments. [4] and Beta [5], is also among the most important influences on the design of the Newspeak language. 2. Traditional Interface Construction This paper focuses on Hopscotch, the applica- tion framework of Newspeak and the Newspeak The art of devising forms to be filled in depends IDE implemented concurrently with the frame- on three elements: obscurity, lack of space, and work. The framework and the IDE allow easy nav- the heaviest penalties for failure.
    [Show full text]
  • Smalltalk Tutorial for Java Programmers!
    SmallTalk Tutorial for Java Programmers! SmallTalk Tutorial for Java Programmers! Giovanni Giorgi <[email protected]> Jan 2002 A small paper to teach yourself the incredible Smalltalk language! It's so easy, it's so fun! 1. Introduction ● 1.1 Revision history ● 1.2 Conventions used in this paper ● 1.3 Distribution Policy ● 1.4 Why Smalltalk? ● 1.5 Background Required 2. Why Smalltalk is so strange? (or a brief history of Smalltalk) ● 2.1 Download Right Now! ● 2.2 Hello world in Smalltalk ● 2.3 Big Numbers ● 2.4 Code Blocks ● 2.5 The while loop 3. Main Differences between Java and Smalltalk http://daitanmarks.sourceforge.net/or/squeak/squeak_tutorial.html (1 of 2) [1/7/2002 20:44:13] SmallTalk Tutorial for Java Programmers! ● 3.1 Java Versus Smalltalk ● 3.2 Types? No thank you!! ● 3.3 The Squeak base library compared with Java ● 3.4 The Smalltalk Code database ● 3.5 Multiple-Inheritance 4. Ending Words ● 4.1 Going on ● 4.2 Commercial and free products list ● 4.3 References http://daitanmarks.sourceforge.net/or/squeak/squeak_tutorial.html (2 of 2) [1/7/2002 20:44:13] SmallTalk Tutorial for Java Programmers!: Introduction 1. Introduction This paper will teach you the basics of Smalltalk80 language. This tutorial suites the needs of C and Java programmers. But the tutorial can be understanded by everyone knowing a bit of C and/or OOP concepts, as we'll see. Because I will refer a lot to other books and use a lot of technical terms, I'll try to enjoy you while reading.
    [Show full text]
  • This Is the Author's Version of a Work Accepted for Publication by Elsevier
    NOTICE: This is the author’s version of a work accepted for publication by Elsevier. Changes resulting from the publishing process, including peer review, editing, corrections, structural formatting and other quality control mechanisms, may not be reflected in this document. A definitive version was subsequently published in the Journal of Systems and Software, Volume 86, Issue 2, pp. 278-301, February 2013. Efficient Support of Dynamic Inheritance for Class- and Prototype-based Languages Jose Manuel Redondo, Francisco Ortin University of Oviedo, Computer Science Department, Calvo Sotelo s/n, 33007, Oviedo, Spain Abstract Dynamically typed languages are becoming increasingly popular for different software devel- opment scenarios where runtime adaptability is important. Therefore, existing class-based plat- forms such as Java and .NET have been gradually incorporating dynamic features to support the execution of these languages. The implementations of dynamic languages on these platforms com- monly generate an extra layer of software over the virtual machine, which reproduces the reflective prototype-based object model provided by most dynamic languages. Simulating this model fre- quently involves a runtime performance penalty, and makes the interoperation between class- and prototype-based languages difficult. Instead of simulating the reflective model of dynamic languages, our approach has been to extend the object-model of an efficient class-based virtual machine with prototype-based seman- tics, so that it can directly support both kinds of languages. Consequently, we obtain the runtime performance improvement of using the virtual machine JIT compiler, while a direct interoperation between languages compiled to our platform is also possible. In this paper, we formalize dynamic inheritance for both class- and prototype-based languages, and implement it as an extension of an efficient virtual machine that performs JIT compilation.
    [Show full text]
  • Lumi`Ere: a Novel Framework for Rendering 3D Graphics in Smalltalk
    banner above paper title Lumiere` : a Novel Framework for Rendering 3D graphics in Smalltalk Fernando Olivero, Michele Lanza, Romain Robbes REVEAL@ Faculty of Informatics - University of Lugano, Switzerland ffernando.olivero,michele.lanza,[email protected] Abstract One of the cornerstones of Lumiere` is to hinge on the metaphor To render 3D graphics there is a number of different frameworks of a stage. We believe this helps to make the framework and its written in Smalltalk. While most of them provide powerful facil- usage more intuitive, as metaphors are powerful tools to assist ities, many of them are outdated, abandoned, undocumented or the usage of abstract concepts: If a framework is built around an heavyweight. intuitive metaphor which maps abstracts concepts to real-world In this paper we present Lumiere` , a novel lightweight frame- objects, programmers can obtain an immediate mental model of work for rendering 3D graphics using OpenGL based on a stage the framework’s domain model, thus easing the understanding and metaphor. Lumiere` is implemented using the Pharo IDE. In its cur- usage of the framework. rent state it supports basic and composite shapes to populate 3D To apply this concept to 3D graphics, Lumiere` ’s stage metaphor scenes, features a camera, and a lighting model. implies that all graphics are produced by cameras taking pictures We illustrate the usage of Lumiere` with Gaucho, an environ- of 3D shapes lit by the lights of the stage. A stage provides the ment for visual programming we are currently building. setting for taking pictures of a composition of visual objects we call micro-worlds.
    [Show full text]
  • A Browser for Incremental Programming
    Portland State University PDXScholar Computer Science Faculty Publications and Presentations Computer Science 9-2003 A Browser for Incremental Programming Andrew P. Black Portland State University, [email protected] Follow this and additional works at: https://pdxscholar.library.pdx.edu/compsci_fac Part of the Programming Languages and Compilers Commons, and the Software Engineering Commons Let us know how access to this document benefits ou.y Citation Details Schärli, Nathanael, and Andrew P. Black. "A browser for incremental programming." Computer Languages, Systems & Structures 30.1 (2004): 79-95. This Post-Print is brought to you for free and open access. It has been accepted for inclusion in Computer Science Faculty Publications and Presentations by an authorized administrator of PDXScholar. Please contact us if we can make this document more accessible: [email protected]. A Browser for Incremental Programming Nathanael Scharli¨ a,∗ Andrew P. Black b aSoftware Composition Group, University of Bern, Switzerland bOGI School of Science & Engineering, Oregon Health & Science University, USA Abstract Much of the elegance and power of Smalltalk comes from its programming environment and tools. First introduced more than 20 years ago, the Smalltalk browser enables programmers to “home in” on particular methods using a hierarchy of manually-defined classifications. By its nature, this clas- sification scheme says a lot about the desired state of the code, but little about the actual state of the code as it is being developed. We have extended the Smalltalk browser with dynamically computed virtual categories that dramatically improve the browser’s support for incremental programming. We illustrate these improvements by example, and describe the algorithms used to compute the virtual categories efficiently.
    [Show full text]
  • COSC345 Week 21 Notes
    COSC345 Week 21 Notes There are handouts about the spiral model: a copy of Boehm’s paper, and the Wikipedia page about it. “Prototyping is about risk reduction: if you don’t have a question, you don’t need a prototype” is the heart of it. The edition of Pressman I intended is the old one listed in the Bibliography. The section about “Developers and Users are different” is really quite impor- tant. It might even deserve to be in a lecture of its own, though not necessarily in this paper. I once had a student (who became a highly paid consultant in the UK) who was into Neuro-Linguistic Programming; it seems they not only clas- sify people’s thinking styles as (Visual/Auditory/Tactile)×(Digital/Analogue) but have techniques for determining which someone is. It’s quite interesting to get someone to describe something abstract and note what kinds of metaphors they use; the point is that people use different ones. There are the classic Four Temperaments (Choleric, Melancholic, Phlegmatic, and Sanguine) and the mod- ern refinement of it, the Enneagram. People always seem to be fascinated to be told about themselves, so getting the members of the class to do some kind of quick personality test and then collecting the results anonymously and tab- ulating them might be a fun way to make the point that people really do think differently. Here’s one: http://similarminds.com/test.html Of course, it’s not just developers and users who differ. Users differ from each other. The point is to remind students that they cannot expect other people to think exactly like them and to enjoy exactly what they enjoy.
    [Show full text]
  • Reading Smalltalk
    How to Read Smalltalk JAS Research CS OO Languages Smalltalk readingSmalltalk Reading Smalltalk My presentation is based on the way I tackle any language: 1. Examine the character set and tokens 2. Examine the reserved words 3. Examine each unique syntactic form 4. Examine each unique semantic form 5. Examine the libraries So here goes... 1. Character set and tokens Standard character set, with twelve special characters: #:^.'|";()[] The tokens are: {identifier} {number} {string} {comment} {binaryOperator} {keyword} {specialToken} Identifiers are the same as you'd expect, except that we use capitalLettersLikeThis, rather_than_underscores. Numbers are also as you'd expect. 'Strings' 'are enclosed in single quotes' "Comments" "are enclosed in double quotes" Binary operators are composed of one or two characters. The characters which can form a {binaryOperator} vary a little bit between implementations, but for the purpose of reading Smalltalk, you can assume that any non-alphaNumeric character which is not in the above list of {special characters} forms a {binaryOperator}. For example, + is a {binaryOperator}. ++ is a {binary operator}. ?* is a {binaryOperator}. -> is a {binaryOperator}. A keyword: is just an identifier with a colon on the end of it, e.g. anyIdentifierLikeThis: is a {keyword}. In Smalltalk, a keyword is only special in the sense that it forms a "keyword message". It is a distict kind of token (different from an identifier or a string) but it's meaning as an individual token is not special. Some languages have {keywords} like BEGIN and END with builtin special meanings. {Keyword} in Smalltalk is not this sort of thing, it's strictly a syntactic form.
    [Show full text]
  • Towards Version Control in Object-Based Systems
    Towards Version Control in Object-based Systems Jakob Reschke, Marcel Taeumel, Tobias Pape, Fabio Niephaus, Robert Hirschfeld Technische Berichte Nr. 121 des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam ISBN 978-3-86956-430-2 ISSN 1613-5652 Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam | 121 Jakob Reschke | Marcel Taeumel | Tobias Pape | Fabio Niephaus | Robert Hirschfeld Towards Version Control in Object-based Systems Universitätsverlag Potsdam Bibliografische Information der Deutschen Nationalbibliothek Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.dnb.de/ abrufbar. Universitätsverlag Potsdam 2018 http://verlag.ub.uni-potsdam.de/ Am Neuen Palais 10, 14469 Potsdam Tel.: +49 (0)331 977 2533 / Fax: 2292 E-Mail: [email protected] Die Schriftenreihe Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam wird herausgegeben von den Professoren des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam. ISSN (print) 1613-5652 ISSN (online) 2191-1665 Das Manuskript ist urheberrechtlich geschützt. Druck: docupoint GmbH Magdeburg ISBN 978-3-86956-430-2 Zugleich online veröffentlicht auf dem Publikationsserver der Universität Potsdam: URN urn:nbn:de:kobv:517-opus4-410812 http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-410812 Version control is a widely used practice among software developers. It reduces the risk of changing their software and allows them to manage different configurations and to collaborate with others more efficiently. This is amplified by code sharing platforms such as GitHub or Bitbucket.
    [Show full text]
  • Why Smalltalk James Robertson Independent Consultant Smalltalk Evangelist
    Why Smalltalk James Robertson Independent Consultant Smalltalk Evangelist http://www.jarober.com Friday, December 9, 2011 Origins • Xerox PARC • Where all the other good stuff came from • Designed to be easy to learn Friday, December 9, 2011 Origins • Message Passing: You tell objects what to do • Easy to read syntax: More like human language • Complexity in the library, not in the language Friday, December 9, 2011 What’s Cool About It? Friday, December 9, 2011 Maturity • Smalltalk has been in widespread use since the mid ‘80s • Multiple implementations • Commercial • Open Source • It’s influence is felt beyond the Smalltalk community Friday, December 9, 2011 Influences • Sun almost picked Smalltalk • ParcPlace was too greedy for license fees • Instead, Oak became Java, with major influences from Smalltalk Friday, December 9, 2011 Influences • Java • Class Based • Single Inheritance • VM/byte code system • Portability Friday, December 9, 2011 Influences • Erlang • Joe Armstrong originally wanted to use Smalltalk • At the time, it was not ready for what he needed, and the vendors were slow to respond • Developed the concurrency model for Erlang around message passing • Erlang itself has gone on to influence concurrency models in language design Friday, December 9, 2011 Influences • Dart • Developed by Gilad Bracha and Lars Bok • Both have delivered Smalltalk derived systems (Newspeak, OOVM) Friday, December 9, 2011 Influences • Dart • Class Based • Single Inheritance • Optional Typing (Dynamic) • Supports Named Parameters (readability) • Built
    [Show full text]
  • Dynamic Language Embedding
    Dynamic Language Embedding With Homogeneous Tool Support Inauguraldissertation der Philosophisch-naturwissenschaftlichen Fakultät der Universität Bern | downloaded: 27.9.2021 vorgelegt von Lukas Renggli von Entlebuch Leiter der Arbeit: Prof. Dr. O. Nierstrasz Institut für Informatik und angewandte Mathematik https://doi.org/10.7892/boris.104713 source: This dissertation is available as a free download from scg.unibe.ch. Copyright © 2010 Lukas Renggli, www.lukas-renggli.ch. The contents of this dissertation are protected under Creative Commons Attribution-ShareAlike 3.0 Unported license. For any reuse or distribution, you must make clear to others the license terms of this work. The best way to do this is with a link to creativecommons.org/licenses/by-sa/3.0/. First Edition, October, 2010. Cover art by Martin Renggli. Acknowledgements First of all, I would like to express my gratitude to Oscar Nierstrasz for giving me the opportunity to work at the Software Composition Group. I thank him for his advice and support throughout the years. I would like to thank Ralf Lämmel for writing the Koreferat and for accepting to be on the PhD committee. I enjoyed the good discussions we had when we met in Bern, Koblenz and at various language engineering conferences. I thank Matthias Zwicker for accepting to chair the examination. I am grateful to Stéphane Ducasse for his enthusiasm and the numerous invitations to join him at his research group in Annecy and later in Lille. I might not have taken the path of pursuing a PhD without the encouragements of him. I also thank Tudor Gîrba for the inspiring discussions and for providing many of the ideas that have influenced this work.
    [Show full text]
  • HTML5 Parser
    HTML5 Parser Dissertation submitted to the University of Manchester for the degree of Master of Science in the Faculty of Computer Science. 2013 Mohammad Al Houssami School of Computer Science The Author Mohammad Al Houssami has a Bachelors Degree in Computer Science from the American University of Beirut in June 2012 and currently pursuing a degree in Advanced Computer Science with concentration on Software Engineering. Apart from the current work done on both project and research no previous work was done. The bachelor’s degree acquired did not include any projects or research to be done. Knowledge in the field of HTML in general and HTML5 specifically was very basic before the project. Parsing markup was introduced during the semi-structured data and the Web. 2 Abstract As HTML5’s key feature is the detailed algorithm designed to parse any arbitrary content, the project is about producing an independent implementation for the HTML5 parsing algorithm. The project is built for the Smalltalk community which does not have its own native parser. The implementation also has a testing suite that can be used to check if things are broken or to continue the development on the project. As a final step, the project offers feedback to the standardization groups. The paper includes a brief history of HTML and parsing. A part of the paper is dedicated for the language before going into the details of the implementation and the challenges faced. A simple guide to continue the implementation is also provided in the paper for individuals aiming to complete the parser.
    [Show full text]
  • ESUG Lessons.Davetho
    You Can’t Do That With Smalltalk! - Can You? Lessons From The Past – Challenges For The Future Dave Thomas Bedarra Corporation (Canada and Anguilla) Carleton University (Canada) and University Of Queensland (Australia) [email protected] © Bedarra Corp 2002 About The Talk • Brief History Of Commercial Smalltalk • Yes You Can! – The OTI Smalltalk Experience • Opportunities For Smalltalk • In Search of Sapphire – ScriptingSmallatalk • Summary © Bedarra Corp 2002 Commercial Smalltalk The Early Years 1984 - 1994 • PPS Smalltalk Dynamic Translation – Peter Deutsch • Tektronix AI Workstation • Digitalk Methods and Smalltalk/V • Apple Lisa Smalltalk • Berkeley Smalltlak - Generation Scavenging • Gemstone • ST/VMac Digitalk and OTI • OTI Envy/Developer • Tektronix Oscilloscopes and OTI Embedded Smalltalk/V, CRC, RDD © Bedarra Corp 2002 Commercial Smalltalk The Early years 1984 - 1995 • Instantiations TeamV, KSC mentoring, Object People - Toplink, Objectshare WindowBuilder • Digitalk VisualSmalltalk, PPS Visualworks, Envy Smalltalk, Smalltalk/X • ANSI ST, IBM VisualAge/Smalltalk and Mainframe Smalltalk • QKS Smalltalk Agents, Dolphin Smalltalk, MTS Smalltalk • Optimizations – Polymorphic Inline Cache • Namespaces and Packages © Bedarra Corp 2002 Commercial Smalltalk Research and Development Post 1995 • StrongTalk, OTI Uvm, Smalltalk/X Java Extensions, PPS Jigsaw (last major commercial R&D) • Circa 95/96 – Dolphin, Smalltalk MT, Squeak © Bedarra Corp 2002 Once Upon A Time A Long Long Time Ago • A small new CS department with 3 Professors wanted to
    [Show full text]