This document discusses the Mist programming language and environment. It provides an overview of Mist's goals which include self-sufficiency, simplicity, consistency, speed and allowing for "craziness". It describes Mist's implementation strategies such as spending memory freely, starting simple and going for 80/20 solutions. Technically, Mist compiles to an intermediate representation called Fog, which then compiles to machine code. Mist uses garbage collection, tail call elimination and traits as language features.

1. Martin is getting
the projector
to work
with his laptop.

2. Classes in the Mist
A Non-
Traditional
Smalltalk Gets
Classy
Martin McClure

3. There is no “I”
in “Team”

4. There is no “C”
in “Smalltalk”

5. Mist
•Open-source (MIT)
•mist-project.org
(see previous videos)
•Github

6. Status
(overview)

7. Status
(overview)
Why Now?

8. Values
•Self-sufficiency
•Simplicity
•Consistency
•Speed
•Craziness

9. Self-Sufficiency

10. Minimize Dependencies

11. Minimize Dependencies
Maximize Interoperability

12. Simplicity

13. Consistency

14. Speed

15. Craziness

16. “If you aren't doing some
things that are crazy, you're
doing the wrong things”
Larry Page, Google CEO

17. Values
•Self-sufficiency
•Simplicity
•Consistency
•Speed
•Craziness

18. Strategies
•Spend memory freely
•Start simple
•Broad solutions
•Unconventional first
•Go for the 80/20

19. Implementation

20. Initial Target
X86_64 Linux

21. Mist
compiles to
Fog
compiles to
machine code

22. Primitives are written directly
in
Fog

23. Executable image

24. Fully Dynamic

25. Object Headers

26. Object Headers
NO

27. Object Headers
Instance Variables

28. Memory
Management

30. Garbage Collection
gcMark
isGcMarked
ifFalse: [isGcMarked := true.
self allReferencesDo:
[:each | each gcMark]]
gcSweep
isGcMarked
ifTrue: [isGcMarked := false]
ifFalse: [|size|
size := self physicalSize.
class := FreeSpace.
self physicalSize: size.
TheObjectManager
add: self toFreeListForSize: size]

31. Tail Call Elimination

32. Loop using recursion
SmallInteger
to: limit byPositive: increment do: aBlock
| nextIndex |
aBlock value: self.
nextIndex := self + increment.
^ nextIndex > limit
ifFalse: [nextIndex
to: limit
byPositive: increment
do: aBlock].

33. Loop with Tail Call
Elimination
SmallInteger
to: limit byPositive: increment do: aBlock
| nextIndex |
aBlock value: self.
nextIndex := self + increment.
^ nextIndex > limit
ifFalse: [nextIndex
to: limit
byPositive: increment
do: aBlock].

34. Loop with Tail Call
Elimination
False
ifFalse: aBlock
^ aBlock value.
<this block's closure class>
value
^ nextIndex
to: limit
byPositive: increment
do: aBlock.

35. Language
Features

36. Traits

37. Stateful Traits
Name:
IdentityHash
Instance Variables:
identityHash
Methods:
identityHash
identityhash == nil
ifTrue: [identityHash := Random integer].
^identityHash

38. Indexed instvars as a
trait

39. Do you
need both concepts?

40. Classes Compose...

41. ...but Do Not Inherit

42. Methods
● Compose as in traits
● Rename or omit on conflict
● Can declare private
● No super send
● Special behavior of self send

43. Instvars
● Private to defining class
● Name conflicts impossible
● Indexed instvars – some fussing needed

44. Abstract Class
● #basicNew not understood
● “class” instvar not present

45. Concrete Class
● Compose one concrete class
...and only one

46. Class
Composition
vs
Object Composition

47. Modules

48. Variables
● Args and temps
● Instance variables
● Module variables
– Class names
● Class variables?
– Compile-time constants

49. Safety
● Privacy
● Teams

50. Massively Single-
threaded

51. No String Literals

52. Stream Literals
'Name: [name] Address: [address]'

53. Status
(detailed)

54. Classes in the Mist
A Non-
Traditional
Smalltalk Gets
Classy
Martin McClure