smalltalk in a net world n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Smalltalk in a .NET World PowerPoint Presentation
Download Presentation
Smalltalk in a .NET World

Loading in 2 Seconds...

play fullscreen
1 / 29

Smalltalk in a .NET World - PowerPoint PPT Presentation


  • 126 Views
  • Uploaded on

Smalltalk in a .NET World. How to write a Smalltalk compiler without writing a VM John Brant brant@refactory.com. #Smalltalk. Open source Smalltalk compiler Complete Source Available Self hosting Compiles Smalltalk directly to .NET executables and libraries. Building Smalltalk.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Smalltalk in a .NET World' - bradley-albert


Download Now An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
smalltalk in a net world

Smalltalk in a .NET World

How to write a Smalltalk compiler without writing a VM

John Brant

brant@refactory.com

smalltalk
#Smalltalk
  • Open source Smalltalk compiler
  • Complete Source Available
  • Self hosting
  • Compiles Smalltalk directly to .NET executables and libraries
building smalltalk
Building Smalltalk
  • Virtual Machine
    • .NET Virtual Machine
  • Compiler
    • RB parser
  • Class Library
    • ANSI Standard
  • Development tools (debuggers, browsers, etc.)
what s net anyway
What’s .NET Anyway?
  • Common class library (collections, GUI, sockets, database, etc.)
  • Common virtual machine and byte code instruction set
  • Language isn’t supposed to matter
why net business reasons
Why .NET?(business reasons)
  • Backed by Microsoft
  • Lots of existing code
  • Allow Smalltalk to be used for applications that “require .NET”
why net personal reasons
Why .NET?(personal reasons)
  • Build a Smalltalk compiler
  • Make an experimental platform
  • Learn .NET
  • Unemployed
dynamic typing
Dynamic Typing
  • Root super type
  • Understands every message
  • Sends #doesNotUnderstand:

printString

^self doesNotUnderstand:

(Message

selector: #printString

arguments: #())

printString

| stream |

stream := WriteStream with: String new.

self printOn: stream.

^stream contents

null vs nil

method: aBoolean

| temp one |

aBoolean ifTrue: [temp := 5].

one := 1.

^temp + one

temp := nil.

null vs. nil
  • Special object for nil
  • Class constructor initializes variables to nil
  • Method temporaries initialized to nil only if they could be read before written
smallintegers

2r00001011

2r00000010

SmallIntegers
  • No support for tagged integers
  • Real integer objects
  • 10x slower than tagged integers

VW Tagged

#Smalltalk

blocks
Blocks
  • Create class for each block
  • Create object from block class at runtime

method

^#(1) collect: (Method-Block new)

MonadicBlock subclass: Method-Block

instanceVariableNames: ‘’

value: each

^each + 1

method

^#(1) collect:

[:each | each + 1]

block variables

method

arg

block

block

temp

arg

temp

temp

value

Block Variables
  • Variable references
    • Copied values (method/block arguments)
    • Active variables (temporaries)

arg

method: arg

| block temp |

block := [temp + arg].

temp := 5.

^block value

5

block returns

method1

self method2: [^1]

method2: aBlock

#(2) do:

[:each |

aBlock value.

^each]

method1[ ]

method2[ ]

do:

method2

method1

Block Returns
  • Simulate using .NET exceptions
  • 100x slower
  • Tag object (integer)
primitives
Primitives
  • Some actions aren’t representable (e.g., identityHash, +, etc.)
  • Primitive tag
    • Only one per method
  • Compiler primitive: []
    • Used anywhere in method
    • User can add new primitives
    • Block code evaluated at compile time
primitive example
Primitive Example

identityHash

^Compiler

primitive:

[:codeGenerator |

codeGenerator

call: (System.Object getMethod: 'GetHashCode');

constructNewObject: codeGenerator smalltalk

smallIntegerClass initializedConstructor]

evaluate: self

optimized messages
Optimized Messages
  • Certain messages aren’t sent (e.g., ifTrue:, whileTrue:, to:do:)
  • Can hard code in compiler
  • Instead use macros and “Compiler primitive: []” syntax
macros
Macros
  • RB’s rewrite rules
    • ``@node ifTrue: ``@block Compiler primitive: [:codeGen :block | …] evaluate: ``@node uses: ``@block
  • Allows arbitrary optimizations (e.g., ifNil:  isNil ifTrue:)
  • Copy source interval for debugger
connecting with net
Connecting with .NET
  • Over 2500 classes provided
  • Seamless integration

| algorithm stream |

algorithm := HashAlgorithm create: ‘MD5’.

stream := FileStream read: ‘rb.im’.

[algorithm computeHash: stream]

ensure: [stream close]

connecting smalltalk to net
Connecting Smalltalk to .NET
  • Class references (Convert or System.Convert)
  • Typed Variables (System.Int32)
  • Generic ObjectWrapper
  • Messages for field, property, and method access
  • Constructors – #new* messages
method arguments
Method arguments
  • First keyword for method name/rest can be anything
  • Arguments converted to .NET objects
    • is-a tests for arguments
  • Overloaded methods left-to-right, specific-to-generic
    • System.Console::Write(int/char/…/object)
console example
Console Example

System.Console write: anObject

(anObject isKindOf: SmallInteger)

ifTrue: [System.Console write: anObject integer]

ifFalse:

[(anObject isKindOf: Character)

ifTrue: [System.Console write: anObject character]

ifFalse:

[(anObject isKindOf: String)

ifTrue: [System.Console write: anObject string]

ifFalse: [System.Console write: anObject]]]

connecting net to smalltalk
Connecting .NET to Smalltalk
  • Events use add_EventName: / remove_EventName: methods
  • Delegates (#asDelegate:)

Button new add_Click: ([:obj :args | …] asDelegate: EventHandler)

  • Exported Properties/Methods (specified by annotations)
  • Interfaces & subclasses (to do)
smalltalk development version 1
#Smalltalk Development (Version 1)
  • Proof of concept
  • VisualWorks program
  • Compiled generated text file with ilasm (.NET’s assembler)
  • Not seamless
smalltalk development version 2
#Smalltalk Development (Version 2)
  • Read .SIF files
  • VisualWorks DLL connection to .NET
  • Override qualified name lookup in VW to use .NET DLL
    • System.Int32 Parse: ‘1234’
  • System.Reflection.Emit generate .exe file directly
smalltalk development version 3
#Smalltalk Development (Version 3)
  • Code based on Version 2
  • Self hosting
  • Complete .exe compiler
  • Compile three times (fixed point)
    • Old code compiling new code
    • New code compiling new code
    • Verify new code compiled new code valid
future work
Future work
  • IDE (GUI builders, Browsers, etc.)
  • Add Subclassing/Interfaces
  • Optimizations
    • Reusing intermediate numerical values (e.g., i + j + k)
    • Type inferencing – eliminating SmallIntegers (e.g., 1 to: 10 do: [:i | ])
  • Write programs
contact information
Contact Information
  • #Smalltalk
    • http://www.refactory.com/Software/SharpSmalltalk/
  • VisualWorks .NET DLL
    • http://www.rileywhite.com/software/assemblyconnect.html
  • .NET
    • http://www.microsoft.com/net/
    • http://www.go-mono.com/