Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

A brief history of Smalltalk in Brussels by Theo D'Hondt

176 views

Published on

A brief history of Smalltalk in Brussels by Theo D'Hondt

Published in: Technology
  • Login to see the comments

  • Be the first to like this

A brief history of Smalltalk in Brussels by Theo D'Hondt

  1. 1. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels Growing an Abstract Grammar Teaching Language Engineering Theo D'Hondt Software Languages Lab Vrije Universiteit Brussel soft.vub.ac.be tjdhondt@vub.ac.be A brief history of Smalltalk in Brussels
  2. 2. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels Growing an Abstract Grammar Teaching Language Engineering Theo D'Hondt Software Languages Lab Vrije Universiteit Brussel soft.vub.ac.be tjdhondt@vub.ac.be A brief history of Smalltalk in Brussels Vrije Universiteit Brussel
  3. 3. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels Growing an Abstract Grammar Teaching Language Engineering Theo D'Hondt Software Languages Lab Vrije Universiteit Brussel soft.vub.ac.be tjdhondt@vub.ac.be A brief history of Smalltalk in Brussels Vrije Universiteit Brussel Software Languages Lab
  4. 4. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels Growing an Abstract Grammar Teaching Language Engineering Theo D'Hondt Software Languages Lab Vrije Universiteit Brussel soft.vub.ac.be tjdhondt@vub.ac.be A brief history of Smalltalk in Brussels Vrije Universiteit Brussel Software Languages Lab "He is an emeritus faculty member of the Software Languages Lab of the Vrije Universiteit Brussel, a software and language engineering lab with roots going back to 1987. He also helped establish the computer science programme in 1978, one of the most advanced in the country. He gradually moved from the higher level engineering of programming languages to virtual machines and is currently mostly interested in implementation technology for these."
  5. 5. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 2 Abstract When in May 1983 the Blue Book was published, one of the very first places where Smalltalk took root in Europe was Brussels. When furthermore a Smalltalk image and a virtual machine specification was distributed (on tape), one of the very first European Smalltalk implementations took shape in that same Brussels. This talk will cover the evolution of Smalltalk from these initial experiments to a major tool in research and education, but also in software development. We will discuss the initial seduction of Smalltalk leading to a more mature assessment over the years leading to a much more discreet role in recent times. And we will finish by speculating about the role of Smalltalk today, and ranging a bit more widely over the role of programming and object-oriented programming in particular.
  6. 6. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 3 The blue book: 1983 The Hardware The Smalltalk-80 implementation has been described as a virtual machine to avoid unnecessary hardware dependencies. It is naturally assumed that the hardware will include a processor and more than enough memory to store the virtual image and the machine language routines simulating the interpreter and object memory. The current size of the virtual image requires at least a half megabyte of memory.     The size of the processor and the organization of the memory are not actually constrained by the virtual machine specification. Since object pointers are 16 bits, the most convenient arrangement would be a 16-bit processor and a memory of 16-bit words. As with the processor and memory of any system, the faster the better.     The other hardware requirements are imposed by the primitives that the virtual image depends on. These input-output devices and clocks are listed below. 1 A bitmap display. It is most convenient if the bitmap being displayed can be located in the object memory, although this is not absolutely necessary. 2 A pointing device. 3 Three buttons associated with the pointing device. It is most convenient if these are physically located on the device. 4 A keyboard, either decoded ASCII or undecoded ALTO. 5 A disk. The standard Smalltalk-80 virtual image contains only a skeleton disk system that must be tailored to the actual disk used. 6 A millisecond timer. 7 A real time clock with one second resolution.
  7. 7. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 3 The blue book: 1983 The Hardware The Smalltalk-80 implementation has been described as a virtual machine to avoid unnecessary hardware dependencies. It is naturally assumed that the hardware will include a processor and more than enough memory to store the virtual image and the machine language routines simulating the interpreter and object memory. The current size of the virtual image requires at least a half megabyte of memory.     The size of the processor and the organization of the memory are not actually constrained by the virtual machine specification. Since object pointers are 16 bits, the most convenient arrangement would be a 16-bit processor and a memory of 16-bit words. As with the processor and memory of any system, the faster the better.     The other hardware requirements are imposed by the primitives that the virtual image depends on. These input-output devices and clocks are listed below. 1 A bitmap display. It is most convenient if the bitmap being displayed can be located in the object memory, although this is not absolutely necessary. 2 A pointing device. 3 Three buttons associated with the pointing device. It is most convenient if these are physically located on the device. 4 A keyboard, either decoded ASCII or undecoded ALTO. 5 A disk. The standard Smalltalk-80 virtual image contains only a skeleton disk system that must be tailored to the actual disk used. 6 A millisecond timer. 7 A real time clock with one second resolution.
  8. 8. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 3 The blue book: 1983 The Hardware The Smalltalk-80 implementation has been described as a virtual machine to avoid unnecessary hardware dependencies. It is naturally assumed that the hardware will include a processor and more than enough memory to store the virtual image and the machine language routines simulating the interpreter and object memory. The current size of the virtual image requires at least a half megabyte of memory.     The size of the processor and the organization of the memory are not actually constrained by the virtual machine specification. Since object pointers are 16 bits, the most convenient arrangement would be a 16-bit processor and a memory of 16-bit words. As with the processor and memory of any system, the faster the better.     The other hardware requirements are imposed by the primitives that the virtual image depends on. These input-output devices and clocks are listed below. 1 A bitmap display. It is most convenient if the bitmap being displayed can be located in the object memory, although this is not absolutely necessary. 2 A pointing device. 3 Three buttons associated with the pointing device. It is most convenient if these are physically located on the device. 4 A keyboard, either decoded ASCII or undecoded ALTO. 5 A disk. The standard Smalltalk-80 virtual image contains only a skeleton disk system that must be tailored to the actual disk used. 6 A millisecond timer. 7 A real time clock with one second resolution.
  9. 9. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 3 The blue book: 1983 The Hardware The Smalltalk-80 implementation has been described as a virtual machine to avoid unnecessary hardware dependencies. It is naturally assumed that the hardware will include a processor and more than enough memory to store the virtual image and the machine language routines simulating the interpreter and object memory. The current size of the virtual image requires at least a half megabyte of memory.     The size of the processor and the organization of the memory are not actually constrained by the virtual machine specification. Since object pointers are 16 bits, the most convenient arrangement would be a 16-bit processor and a memory of 16-bit words. As with the processor and memory of any system, the faster the better.     The other hardware requirements are imposed by the primitives that the virtual image depends on. These input-output devices and clocks are listed below. 1 A bitmap display. It is most convenient if the bitmap being displayed can be located in the object memory, although this is not absolutely necessary. 2 A pointing device. 3 Three buttons associated with the pointing device. It is most convenient if these are physically located on the device. 4 A keyboard, either decoded ASCII or undecoded ALTO. 5 A disk. The standard Smalltalk-80 virtual image contains only a skeleton disk system that must be tailored to the actual disk used. 6 A millisecond timer. 7 A real time clock with one second resolution.
  10. 10. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 4 Smalltalk V.2 release
  11. 11. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 5 Prior expertise: M68000Name M68000 Educational Computer Board (Motorola part # MEX68KECB) Manufacturer Motorola Inc. Microsystems Division 3102 North 56th St. Phoenix, AZ 85018 Distributed by Hamilton/Avnet Electronics Hardware Single-board computer. 6-1/2 by 10-1/2 inches, containing a 68000 microprocessor running at 4 MHz; 16K-byte monitor ROM; 32K-byte dynamic RAM; two serial I/O ports with data rate individually selectable from 110 to 9600 bps; MC68230 parallel port/timer that provides three 8-bit parallel ports with handshaking; audio cassette I/ O; Centronics-type printer port; and wire-wrap area. Operation requires an external power supply (+5V at 750 mA, +12V at 100 mA). RS-232C-compatible video terminal, and connecting cable Software 16K-byte monitor ROM with most of the functions of the Motorola Macsbug plus interpretative assembler, disassembler, printer and tape recorder functions, and a series of TRAP #14 functions that allows user program access to most of the monitor data conversion and I/O routines Options Interface cables to connect computer board to terminals, printers Price $495 Warranty 90-day warranty includes parts, labor, and return shipping Documentation Over 450 pages, including data sheets on LSI circuits, a software manual for the 68000, and a manual on the ECB hardware and monitor Audience Educators, students, hard-core hobbyists. and 68000 systems developers who would like to use the ECB as a supplementary aid (BYTE magazine, October 1983)
  12. 12. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 6 Prior expertise: NEC µPD7220
  13. 13. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 7 Needed: 3-button mouse P4
  14. 14. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 8 Boot language: Modula-2
  15. 15. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 9 The hardware: a rack
  16. 16. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 10 The hardware: connections
  17. 17. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 11 The hardware: multibus
  18. 18. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 12 The hardware: processor
  19. 19. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 13 The hardware: memory
  20. 20. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 14 The hardware: graphics
  21. 21. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 15 The hardware: disk controller
  22. 22. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 16 The result ... a VM written in Modula-2 edited on a mainframe cross-compiled to M68k downloaded over serial link 3 students: interpreter memory manager graphics
  23. 23. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 16 The result ... a VM written in Modula-2 edited on a mainframe cross-compiled to M68k downloaded over serial link 3 students: interpreter memory manager graphics
  24. 24. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 16 The result ... a VM written in Modula-2 edited on a mainframe cross-compiled to M68k downloaded over serial link 3 students: interpreter memory manager graphics
  25. 25. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 16 The result ... a VM written in Modula-2 edited on a mainframe cross-compiled to M68k downloaded over serial link 3 students: interpreter memory manager graphics
  26. 26. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 16 The result ... a VM written in Modula-2 edited on a mainframe cross-compiled to M68k downloaded over serial link 3 students: interpreter memory manager graphics
  27. 27. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 16 The result ... a VM written in Modula-2 edited on a mainframe cross-compiled to M68k downloaded over serial link 3 students: interpreter memory manager graphics
  28. 28. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 16 The result ... a VM written in Modula-2 edited on a mainframe cross-compiled to M68k downloaded over serial link 3 students: interpreter memory manager graphics operational but slow
  29. 29. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 17 Symbolics 3600
  30. 30. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 18 Tektronix 4404 TEK REFERENCE " MANUAL First Printing JUNE 1987 Part No. 061-3393-00 Product Group 07 TEKTRONIX SMALLTALK Please Check at the Rear of this Manual for NOTES and CHANGE INFORMATION http://www.wirfs-brock.com/allen/things/smalltalk-things/tektronix-smalltalk-document-archive
  31. 31. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels ∀ object ∀ metaclass ∃! class indexed instance variables bitblt smallint 19 Smalltalk top 5 wow's
  32. 32. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels ∀ object ∀ metaclass ∃! class indexed instance variables bitblt smallint 19 Smalltalk top 5 wow's
  33. 33. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels ∀ object ∀ metaclass ∃! class indexed instance variables bitblt smallint 19 Smalltalk top 5 wow's
  34. 34. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels ∀ object ∀ metaclass ∃! class indexed instance variables bitblt smallint 19 Smalltalk top 5 wow's
  35. 35. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels ∀ object ∀ metaclass ∃! class indexed instance variables bitblt smallint 19 Smalltalk top 5 wow's
  36. 36. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels ∀ object ∀ metaclass ∃! class indexed instance variables bitblt smallint 19 Smalltalk top 5 wow's
  37. 37. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels bytecodes circularity object tables interpreters blocks 20 Smalltalk top 5 non-wow's
  38. 38. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels bytecodes circularity object tables interpreters blocks 20 Smalltalk top 5 non-wow's
  39. 39. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels bytecodes circularity object tables interpreters blocks 20 Smalltalk top 5 non-wow's
  40. 40. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels bytecodes circularity object tables interpreters blocks 20 Smalltalk top 5 non-wow's
  41. 41. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels bytecodes circularity object tables interpreters blocks 20 Smalltalk top 5 non-wow's
  42. 42. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels bytecodes circularity object tables interpreters blocks 20 Smalltalk top 5 non-wow's
  43. 43. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 21 From bitblt to PC#define PixelsPerWord 16 #define BackGroundColours 16 #define NbrVerticalPixels 200 #define NbrHorizontalPixels 640 #define NbrHorizontalWords 40 enum RuleSet { AllZeroes , SrcAndDest , SrcAndNotDest , Src , DestAndNotSrc , Dest , SrcXorDest , SrcOrDest , NotSrcAndNotDest, NotSrcXorDest , NotDest , SrcOrNotDest , NotSrc , NotSrcOrDest , NotSrcOrNotDest , AllOnes }; void Clear(void); void SetWord(int, int, int ); void GetWord(int, int, int *); void SetRule(enum RuleSet); void SetBackGround(int); void SetGraphicsMode(void); void SetAlphaMode(void); /***********************************************/ /* */ /* BITMAP OPERATIONS FOR IBM PC */ /* */ /* using CGA graphics 640*200 */ /* 16 background intensities */ /* */ /* GetWord(w,y,P) get word <wx,y> into P */ /* SetWord(w,y,P) set word <wx,y> to P */ /* SetRule(r) set rule */ /* Clear clear screen */ /* SetGraphicsMode/SetAlphaMode */ /* SetBackGround(bc) */ /* */ /***********************************************/
  44. 44. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 22 Our European Smalltalk friends
  45. 45. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 22 Our European Smalltalk friends us
  46. 46. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 22 Our European Smalltalk friends us Stéphane Ducasse INRIA Lille
  47. 47. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 22 Our European Smalltalk friends us Oscar Nierstrasz University of Bern Stéphane Ducasse INRIA Lille
  48. 48. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 22 Our European Smalltalk friends Michele Lanza Università della Svizzera italiana us Oscar Nierstrasz University of Bern Stéphane Ducasse INRIA Lille
  49. 49. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 22 Our European Smalltalk friends Michele Lanza Università della Svizzera italiana us Robert Hirschfeld Hasso Plattner Institut Oscar Nierstrasz University of Bern Stéphane Ducasse INRIA Lille
  50. 50. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 23 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005
  51. 51. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 23 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994
  52. 52. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 24 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 A Logic Meta-Programming Approach to Support the Co- Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001
  53. 53. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 25 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 Hybrid Aspects for Integrating Rule-Based Knowledge and Object-Oriented Functionality Maja D'Hondt (2004)
  54. 54. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 26 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 Modularizing Advanced Transaction Management Johan Fabry, 2005
  55. 55. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 27 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Integrative Composition of Program Generators Johan Brichau, 2005
  56. 56. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 28 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 Connecting High-Level Business Rules with Object- Oriented Applications: An approach using Aspect- Oriented Programming and Model-Driven Engineering. María Agustina Cibrán (2007)
  57. 57. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 29 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 Supporting Integration Activities in Object- Oriented Applications Veronica Uquillas Gomez, 2012
  58. 58. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 30 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013
  59. 59. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 31 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 Computational reflection
  60. 60. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 32 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 Hypertext
  61. 61. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 33 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 Software reuse
  62. 62. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 34 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 Language symbiosis
  63. 63. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 35 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 Software evolution
  64. 64. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 36 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 Aspects
  65. 65. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 37 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 Software engineering
  66. 66. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 38 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 User interfaces
  67. 67. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 39 Smalltalk in research Hybrid Aspects for Integrating Rule-Based Knowledge and Object- Oriented Functionality Maja D'Hondt (2004) Progressive Mobility Luk Stoops, 2004 Automated Support For Framework-Based Software Evolution Tom Tourwé, 2002 A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts, 2001 Automating Architectural Conformance Checking by means of Logic Meta Programming Kim Mens, 2000 A Formal Foundation for Object-Oriented Software Evolution Tom Mens, 1999 A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems Koen De Hondt, 1998 Type-Oriented Logic Meta Programming Kris De Volder, 1998 Documenting Reuse and Evolution with Reuse Contracts Carine Lucas, 1997 ZYPHER - Tailorability as a Link from Object-Oriented Software Engineering to Open Hypermedia Serge Demeyer, 1996 Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks Patrick Steyaert, 1994 Supporting Concurrency Abstractions in High-level Language Virtual Machines Stefan Marr, 2013 Supporting Integration Activities in Object-Oriented Applications Veronica Uquillas Gomez, 2012 A Logic Meta Programming Foundation for Example-Driven Pattern Detection in Object-Oriented Programs Coen De Roover, 2009 A bottom-up approach to program variation Peter Ebraert, 2009 On the Separation of User Interface Concerns - A Programmer's Perspective on the Modularisation of User Interface Code Sofie Goderis, 2008 A Goal-Driven Approach for Documenting and Verifying Design Invariants Isabel Michiels, 2007 María Agustina Cibrán (2007) Connecting High-Level Business Rules with Object-Oriented Applications: An approach using Aspect-Oriented Programming and Model-Driven Engineering. Maintaining Causality between Design Regularities and Source Code Andy Kellens, 2007 Advanced Round-Trip Engineering: An Agile Analysis-driven Approach for Dynamic Languages Ellen Van Paesschen, 2006 A Concept-Centric Environment for Software Evolution in an Agile Context Dirk Deridder, 2006 Modularizing Advanced Transaction Management Johan Fabry, 2005 Integrative Composition of Program Generators Johan Brichau, 2005 Language engineering
  68. 68. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 40 Smalltalk in education never OO in a first language in CS always strong OO afterwards always Smalltalk as role model "Principles of OO languages" at the master level Smalltalk in "Evolution of Software Languages"
  69. 69. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 40 Smalltalk in education never OO in a first language in CS always strong OO afterwards always Smalltalk as role model "Principles of OO languages" at the master level Smalltalk in "Evolution of Software Languages"
  70. 70. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 40 Smalltalk in education never OO in a first language in CS always strong OO afterwards always Smalltalk as role model "Principles of OO languages" at the master level Smalltalk in "Evolution of Software Languages"
  71. 71. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 40 Smalltalk in education never OO in a first language in CS always strong OO afterwards always Smalltalk as role model "Principles of OO languages" at the master level Smalltalk in "Evolution of Software Languages"
  72. 72. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 40 Smalltalk in education never OO in a first language in CS always strong OO afterwards always Smalltalk as role model "Principles of OO languages" at the master level Smalltalk in "Evolution of Software Languages"
  73. 73. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 40 Smalltalk in education never OO in a first language in CS always strong OO afterwards always Smalltalk as role model "Principles of OO languages" at the master level Smalltalk in "Evolution of Software Languages"
  74. 74. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 41 Smalltalk and Scheme initializeSize "set initial size to 0" size := 0! newIndexAtKey: key "locate index for new key in names" | index | (size + 1 = names size) ifTrue: [ self extend ] . index := ( key hash names size ) + 1 . [ ( names at: index ) = key ] whileFalse: [ (names at: index) isNil ifTrue: [ size := size + 1 . names at: index put: key . ^ index ] . index := ( index names size ) + 1 ] . ^ 0! ! "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- "! FastDictionary class instanceVariableNames: ''! !FastDictionary class methodsFor: 'private'! minimalSize "implementation dependent initial size" ^ 4! ! !FastDictionary class methodsFor: 'instantiation'! new "instantiate new fast dictionary" ^ (super new ) initializeSize! ! AbstractDictionary subclass: #FastDictionary instanceVariableNames: 'size ' classVariableNames: '' poolDictionaries: '' category: 'DemoDictionaries'! !FastDictionary methodsFor: 'statistics'! size "dictionary size" ^size! ! !FastDictionary methodsFor: 'private'! extend "extend implementation by doubling the number of pairs" | oldNames oldValues newSize | oldNames := names. oldValues := values. newSize := names size * 2. names := Array new: newSize. values := Array new: newSize. size := 0 . 1 to: oldNames size do: [ :index | | name | name := oldNames at: index. (name isNil) ifFalse: [ self at: name put: ( oldValues at: index ) ]]! indexAtKey: key "locate index of key in names" | index | index := ( key hash names size ) + 1 . [ ( names at: index ) = key ] whileFalse: [ (names at: index) isNil ifTrue: [ ^ 0 ] . index := ( index names size ) + 1 ] . ^ index!
  75. 75. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 42 Smalltalk and Scheme (cond ((>= (+ (? size) 1) top) (SEND (SELF) extend) (set! top (vector-length (? names))))) (loop (remainder (hash key) top))) ;extend implementation by one pair (METHOD extend () (define old-names (? names)) (define old-values (? values)) (define old-size (vector-length (? names))) (define new-size (* (+ old-size 1) 2)) (! names (make-vector new-size '())) (! values (make-vector new-size '())) (! size 0) (do ((index 0 (+ index 1))) ((= index old-size)) (let ((name (vector-ref old-names index))) (if (not (null? name)) (SEND (SELF) at:put: name (vector-ref old-values index)))))))) (define fast-dictionary (CLASS abstract-dictionary (VAR size 0) ;determine size of dictionary (METHOD size () (? size)) ;locate index of key in names (METHOD index-at-key: (key) (define top (vector-length (? names))) (define (loop index) (define name (vector-ref (? names) index)) (cond ((null? name) '()) ((eq? key name) index) (else (loop (remainder (+ index 1) top))))) (if (zero? top) '() (loop (remainder (hash key) top)))) ;locate index for new key in names (METHOD new-index-at-key: (key) (define top (vector-length (? names))) (define (loop index) (define name (vector-ref (? names) index)) (cond ((null? name) (! size (+ (? size) 1)) (vector-set! (? names) index key) index) ((eq? key name) '()) (else (loop (remainder (+ index 1) top)))))
  76. 76. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels (define-macro VAR (lambda (name value) `(<<VARS>> 'put ',name ',value))) (define-macro METHOD (lambda (msg args . body) `(<<METHODS>> 'put ',msg (lambda (<<CONTEXT>> ,@args) ,@body)))) (define-macro mVAR (lambda (name value) `(<<mVARS>> 'put ',name ,value))) (define-macro mMETHOD (lambda (msg args . body) `(<<mMETHODS>> 'put ',msg (lambda (,@args) ,@body)))) (define-macro ? (lambda (name) `(<<CONTEXT>> '<<GET>> ',name))) (define-macro ! (lambda (name value) `(<<CONTEXT>> '<<SET>> ',name ,value))) (define-macro CLASS (lambda (super . defs) `(letrec ((<<SUPER>> ,super) (<<METHODS>> (<<TABLE>>)) (<<VARS>> (<<SUPER>> '<<COPY>>)) (<<mMETHODS>> (<<TABLE>>)) (<<mVARS>> (<<TABLE>>)) (<<CLASS>> (lambda (msg . args) (if (<<mMETHODS>> 'lookup msg) (apply (<<mMETHODS>> 'get msg) args) (apply <<SUPER>> (cons msg args)))))) (mMETHOD new () (define context (<<VARS>> 'instantiate)) (define (self msg . args) (<<CLASS>> '<<EVAL>> context msg args)) (context 'replace '<<SELF>> self) self) (mMETHOD <<GET>> (name) (if (<<mVARS>> 'lookup name) (<<mVARS>> 'get name) (<<SUPER>> '<<GET>> name))) (mMETHOD <<SET>> (name value) (if (<<mVARS>> 'lookup name) (<<mVARS>> 'replace name value) (<<SUPER>> '<<SET>> name value))) (mMETHOD <<EVAL>> (context msg args) (if (<<METHODS>> 'lookup msg) (apply (<<METHODS>> 'get msg) (cons context args)) (<<SUPER>> '<<EVAL>> context msg args))) (mMETHOD <<COPY>> () (<<VARS>> 'copy)) ,@defs <<CLASS>>))) 43 Smalltalk and Scheme
  77. 77. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels (define-macro VAR (lambda (name value) `(<<VARS>> 'put ',name ',value))) (define-macro METHOD (lambda (msg args . body) `(<<METHODS>> 'put ',msg (lambda (<<CONTEXT>> ,@args) ,@body)))) (define-macro mVAR (lambda (name value) `(<<mVARS>> 'put ',name ,value))) (define-macro mMETHOD (lambda (msg args . body) `(<<mMETHODS>> 'put ',msg (lambda (,@args) ,@body)))) (define-macro ? (lambda (name) `(<<CONTEXT>> '<<GET>> ',name))) (define-macro ! (lambda (name value) `(<<CONTEXT>> '<<SET>> ',name ,value))) (define-macro CLASS (lambda (super . defs) `(letrec ((<<SUPER>> ,super) (<<METHODS>> (<<TABLE>>)) (<<VARS>> (<<SUPER>> '<<COPY>>)) (<<mMETHODS>> (<<TABLE>>)) (<<mVARS>> (<<TABLE>>)) (<<CLASS>> (lambda (msg . args) (if (<<mMETHODS>> 'lookup msg) (apply (<<mMETHODS>> 'get msg) args) (apply <<SUPER>> (cons msg args)))))) (mMETHOD new () (define context (<<VARS>> 'instantiate)) (define (self msg . args) (<<CLASS>> '<<EVAL>> context msg args)) (context 'replace '<<SELF>> self) self) (mMETHOD <<GET>> (name) (if (<<mVARS>> 'lookup name) (<<mVARS>> 'get name) (<<SUPER>> '<<GET>> name))) (mMETHOD <<SET>> (name value) (if (<<mVARS>> 'lookup name) (<<mVARS>> 'replace name value) (<<SUPER>> '<<SET>> name value))) (mMETHOD <<EVAL>> (context msg args) (if (<<METHODS>> 'lookup msg) (apply (<<METHODS>> 'get msg) (cons context args)) (<<SUPER>> '<<EVAL>> context msg args))) (mMETHOD <<COPY>> () (<<VARS>> 'copy)) ,@defs <<CLASS>>))) 43 Smalltalk and Scheme Smalltalk in Scheme in 170 lines
  78. 78. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 44 Smalltalk in development https://www.mediagenix.tv/en/ http://yesplan.be/en/
  79. 79. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 45 How are objects doing? Ubiquity of objects Is everything really an object? Object literacy Is inheritance too complicated? Swiss army knives
  80. 80. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 45 How are objects doing? Ubiquity of objects Is everything really an object? Object literacy Is inheritance too complicated? Swiss army knives
  81. 81. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 45 How are objects doing? Ubiquity of objects Is everything really an object? Object literacy Is inheritance too complicated? Swiss army knives
  82. 82. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 45 How are objects doing? Ubiquity of objects Is everything really an object? Object literacy Is inheritance too complicated? Swiss army knives
  83. 83. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 45 How are objects doing? Ubiquity of objects Is everything really an object? Object literacy Is inheritance too complicated? Swiss army knives
  84. 84. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 45 How are objects doing? Ubiquity of objects Is everything really an object? Object literacy Is inheritance too complicated? Swiss army knives
  85. 85. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 46 How is programming doing? Why abhor dynamic types? How about JS? Academia: formal or empirical The ascendance of language pragmatism Programming as an art
  86. 86. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 46 How is programming doing? Why abhor dynamic types? How about JS? Academia: formal or empirical The ascendance of language pragmatism Programming as an art
  87. 87. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 46 How is programming doing? Why abhor dynamic types? How about JS? Academia: formal or empirical The ascendance of language pragmatism Programming as an art
  88. 88. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 46 How is programming doing? Why abhor dynamic types? How about JS? Academia: formal or empirical The ascendance of language pragmatism Programming as an art
  89. 89. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 46 How is programming doing? Why abhor dynamic types? How about JS? Academia: formal or empirical The ascendance of language pragmatism Programming as an art
  90. 90. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 46 How is programming doing? Why abhor dynamic types? How about JS? Academia: formal or empirical The ascendance of language pragmatism Programming as an art
  91. 91. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 47 The Art, Science, and Engineering of Programming
  92. 92. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 48 The Art, Science, and Engineering of Programming
  93. 93. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 49 The Art, Science, and Engineering of Programming
  94. 94. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels Steering Committee • Theo D’Hondt (Chair) Vrije Universiteit Brussel, Belgium (2020) • Ademar Aguiar University of Porto, Portugal (2023) • Davide Ancona University of Genoa, Italy (2022) • Robert Hirschfeld (Past Chair) Hasso Plattner Institute Potsdam, Germany (2019) • Jane Cleland-Huang (ACM observer) DePaul University, Chicago, USA (ACM SIGSOFT) • Krzysztof Czarnecki University of Waterloo, Canada (2019) • Wolfgang De Meuter Vrije Universiteit Brussel, Belgium (2019) • Erik Ernst Google, Denmark (2018) • Lidia Fuentes Universidad de Málaga, Spain (2019) • Richard P. Gabriel IBM Research, California (2020) • Sudipto Ghosh Colorado State University, USA (2018) • Gary T. Leavens University of Central Florida, USA (2018) • Cristina Videira Lopes University of California Irvine, California (2020) • Patrick Rein (Secretary/Treasurer) Hasso Plattner Institute Potsdam, Germany (2019) • Guido Salvaneschi Technische Universität Darmstadt, Germany (2021) • Manuel Serrano Inria, France (2021) • Mario Südholt École des Mines de Nantes, France (2019) • Peter Thiemann (ACM observer) University of Freiburg, Germany (ACM SIGPLAN) • Eelco Visser Delft University of Technology, The Netherlands (2018) 50 AOSA inc.
  95. 95. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 51 Smalltalk and fun 10 Reasons why I hate Smalltalk. Theo D’Hondt 13th ESUG joint event — August 2005 10. Smalltalk programmers have too much fun for their own good Programming is a serious business and it shouldn’t be fun — and unfortunately programming in Smalltalk seems to be fun. Now one of the few uses of Smalltalk seems to be as a teaching tool, but whenever it is used in this capacity students are lured away from the *real* programming stuff and they are actually spoiled as members of our wonderful workforce of *real* programmers. So maybe we should launch an initiative to stop using Smalltalk in education because of its corruptive influence and its capacity to turn staunch, dependable programmers into mavericks who manage to deliver dependable software faster than people who do it the proper way, using *real* programmers and certainly not having fun along the way! So the conclusion of this exercise is fairly clear: I am standing in front of a group of people that persist in ignoring common practice: you are actually using a simplistic language that hasn’t changed in 20 years, that possesses some really awful features and that on top of this you enjoy using! And yet you say that you can build software faster and better than all of those *real* programmers using *real* languages. This is simply an outrage! But maybe we should encourage you *not* to change the way you are working, horrible as it may sound. After all, we need to be able to show all of these *real* programmers how awful it is to use a non *real* language and Smalltalk will do the trick very nicely...
  96. 96. Buenos Aires, November 2017 Smalltalks 2017: A brief history of Smalltalk in Brussels 51 Smalltalk and fun 10 Reasons why I hate Smalltalk. Theo D’Hondt 13th ESUG joint event — August 2005 10. Smalltalk programmers have too much fun for their own good Programming is a serious business and it shouldn’t be fun — and unfortunately programming in Smalltalk seems to be fun. Now one of the few uses of Smalltalk seems to be as a teaching tool, but whenever it is used in this capacity students are lured away from the *real* programming stuff and they are actually spoiled as members of our wonderful workforce of *real* programmers. So maybe we should launch an initiative to stop using Smalltalk in education because of its corruptive influence and its capacity to turn staunch, dependable programmers into mavericks who manage to deliver dependable software faster than people who do it the proper way, using *real* programmers and certainly not having fun along the way! So the conclusion of this exercise is fairly clear: I am standing in front of a group of people that persist in ignoring common practice: you are actually using a simplistic language that hasn’t changed in 20 years, that possesses some really awful features and that on top of this you enjoy using! And yet you say that you can build software faster and better than all of those *real* programmers using *real* languages. This is simply an outrage! But maybe we should encourage you *not* to change the way you are working, horrible as it may sound. After all, we need to be able to show all of these *real* programmers how awful it is to use a non *real* language and Smalltalk will do the trick very nicely... ... you are actually using a simplistic language that hasn’t changed in 20 years, that possesses some really awful features and that on top of this you enjoy using! And yet you say that you can build software faster and better than all of those *real* programmers using *real* languages ...

×