1. TeSLa researchproduct

2. Why The $@#%! Visual Basic Imports SySTem.STriNg Module Demo Public Sub Main() Dim S = Join(", ", { "Hello", "World"}) End Sub End Module Case insensitive Static class Class imports

3. Why The $@#%! Visual Basic Class Dog Public Event Bark() End Class Dim WithEvents D As New Dog() Sub OnBark() Handles D.Bark Console.WriteLine("Call 911") End Sub Declarative Event Handling "AOP"

4. Why The $@#%! Visual Basic Function F(X As Integer, _ Optional Flag As Boolean = False) _ As String … End Function F (Flag := True, X := 4711) Optional parameters Named arguments

5. Why The $@#%! Visual Basic Class Dog Public Event Bark() Public Default Property Toys(Name As String) _ As Object Get … End Get Set (Value As Object) … End Set End Property End Class Line continuations Indexed Properties

6. With Scope (Power is in the ".") Why The $@#%! Visual Basic Dim D As New Dog() With D.Toys("Bone") = New Bone().Toys!Cat = CatchNeighboursCat() Console.WriteLine(.Toys("Ball").Color) End With With Statement Late binding

7. Late Binding K = J+3 For I=0 To 10 Console.WriteLine(I) Next Dim X As String = 4711 Function F(X) Return X+3 End Function Implicit Explicit Conversions Option Implicit Types Optional

8. Dim WithEvents B As New Button() Sub OnClick(sender As Object, e As EventArgs) _ Handles B.Click End Sub Sub RelaxedOnClick(sender As Object, e As Object) _ Handles B.Click End Sub Can call it can handle it Relaxed delegates

9. Delegate Function F(A As S) As T Function G(B As P) As Q New F(AddressOf G) New F(Function(A) CType(G(CType(A,P)),T) Relaxed delegates Conversion stub

10. _ Function FindName(Source As Object, Name As String) As Object On Error Resume Next If Source.Name = Name Then Return Source End If Dim Children As Object = Source.Children If Children IsNot Nothing Then For Each Child As Object In Children FindName = FindName(Child, Name) If FindName IsNot Nothing Then Return FindName End If Next End If Return Nothing End Function "AOP" Extension Methods Why The $@#%! Visual Basic Unstructured Exception Handling Late binding

11. Late Binding! G |- e As S ~~> e G |- a As T ~~> a Sm(T) As R ~~> f ---------------------------------- G |- e.m(a) As R ~~> f(e,a) Type Rule For Early-Bound Method Invocation

12. Late Binding! G |- e As Object ~~> e G |- a As T ~~> a T g ----------------------------- G |- e.m(a) latecall("m", e, g(a)) Type Rule For Late-Bound Method Invocation

13. Late Binding! s.GetType() S, t.GetType() T Sm(T) f R h ---------------------------- latecall(m,s,t) h(f(s,t)) Operational Semantics For Late-Bound Call VB has multi- methods!

14. Late Binding Class A Sub F(X As String) WriteLine("F(String)") End Sub Sub F(X As Object) WriteLine("F(Object)") End Sub Sub Main() Dim A = New A() Dim S As Object = "Hello" A.F(S) REM Early F(Object) CObj(A).F(S)REM Late F(String) End Sub End Class Type Inference Imports System.Console

15. Meta-circular interpreter [ A+B ] = Add( [ A ], [ B ]) [ A.m(B) ] = Call( [ m ], [ A ], [ B ]) Self interpretation is litmus test for dynamic language

16. G |- e e G |- a a T f G |- m m' ------------------------------------------------------ G |- e.(m)(a) latecall(m', e, f(a)) Replace Constants By Variables Later binding

17. Later Binding Class A Sub F(X As String) WriteLine("F(String)") End Sub Sub F(X As Object) WriteLine("F(Object)") End Sub Sub Main() Dim A = New A() Dim S As Object = "Hello" A.(Console.ReadLine())(S) End Sub End Class

18. Static Typing Where Possible Dynamic Typing Where Necessary VB as the ultimate scripting language

19. e = 8 + 9 \ + 10 d = 4 + 5 + 6 + 7 def options(a=99, b=a+1) [a,b] end redirect_to :action => 'show', :id => 4711 Ruby Smart "inference" Line continuation Default arguments Named arguments via hashes

20. LINQ Project == monad comprehensions in C# & VB VB 9C# 3.0… Standard Query Operators DLinq (relational) XLinq (xml) LINQ Framework

21. Swartz, SETL 1970; Burstall and Darlington, NPL 1977; Turner, KRC 1981; …. Haskell, Python, Scala, … Write programs using mathematical ZF set comprehensions syntax. Wadler 1989 List comprehensions are related to the relational calculus. Wadler 1992 List comprehensions are a special case of monad comprehensions. The Origins of LINQ

22. SELECT X.FirstName, X.LastName FROM Authors AS X WHERE X.City = 'OakLand' oaklands = do{ x <- table authors ; restrict (x!city.==. constant "Oakland") ; project ( au_fname = x!au_fname, au_lname = x!au_lname ) } HaskellDb Query Monad (1997) Query monad intentional representation for expressions

23. var contacts = from c in customers where c.State == "WA" select new { c.Name, c.Phone }; var contacts = customers.Where(c => c.State == "WA").Select(c => new{c.Name, c.Phone}); Query Comprensions In C# 3.0 Syntactic sugar over standard query operations -expression Type inference

24. Query Comprensions In Visual Basic 9 Dim Squares = From N In Range(0,99) Select N*N Dim Pairs = From N In Range(0,9) From C In "ABCDEFGHIJ" Select N, C Dim Evens = From N In (0,99) Where N Mod 2 = 0 Select N Dim ByDigit = From N In (0,99) Group By N Mod 10 Select Key, It

25. Dim Contacts = From C In Customers Where C.State = "WA" Select C.Name, C.Phone Dim Contacts = _ Customers. Where(Function(C) C.State = "WA"). Select(New With {.Name = C.Name,.Phone = C.Phone }) In Visual Basic 9

26. Query Comprensions In Visual Basic 9 Dim MyCDs As IEnumerable(Of _ { Title As String, Artist As String }) = _ From CD In MyMusic Where CD.Genre IsNot Classic Group By Genre = CD.Genre Where Count(CD) > 10 Select Group(CD.Title, CD.Artist) Aggregate comprehensions

27. Query Comprehensions X X,Y From Y In F(X) Joined Xs.SelectMany((X) _ F(X).Select((Y)_ New {X,Y})) Compiled To Standard Query Operators

28. Query Comprehensions X,Y Order By F(X,Y) X,Y Sorted XYs.OrderBy((XY) _ F(XY.X, XY.Y))

29. Query Comprehensions X,Y Where P(X,Y) Filtered XYs.Where((XY) _ P(XY.X, XY.Y))

30. Query Comprehensions A,B Select A = F(X,Y), B = G(X,Y) X,Y projected XYs.Select((XY) _ New {A = F(XY.X, XY.Y), _ B = F(XY.X, XY.Y) })

31. Query Comprehensions A,B, X,Y Group By A = G(X,Y), B = H(X,Y) grouped X,Y XYs.GroupBy((XY) _ New {A = G(XY.X, XY.Y), _ B = H(XY.X, XY.Y) })

32. Extension Methods static class Integer { static void Times (this int x, Action f){ for(var i = 0; i < x; i++) f(i); } 3.Times((x) => { Console.WriteLine(x); }

33. var contacts = customers.Where(c => c.State == "WA").Select(c => new{c.Name, c.Phone}); static class System.Query { public static IEnumerable Where (this IEnumerable src, Func > p); … } Extension Methods Extension method for IEnumerable IEnumerable

34. Dim Contacts = _ Customers.Where(P).Select(R) Module MyExtensions _ Function Where(Of T)( _ [Me] As IEnumerable(Of T), _ P As Func(Of T, Boolean)) _ As IEnumerable(Of T) … End Module In Visual Basic 9 Just CA

35. var contacts = customers.Where(c => c.State == "WA").Select(c => new{c.Name, c.Phone}); class Table : IEnumerable { public Table Where(Expression > p); … } Expression Trees Intensional representation of delegate Table

36. Dim F As Expr = Function(X)X+3 Dim G = F.Compile() Dim Z = G(5) Expression Trees Compile to delegate Convert to expression tree by type Execute

37. var contacts = from c in customers where c.State == "WA" select new { c.Name, c.Phone }; var Joe = new Person{ Name = Joe, Age = 42, Address = { Street = 1th St, City = Seattle } } Anonymous types, Object initializers Anonymous types Initialize RO member Object Initializers

38. Dim Contacts As IEnumerable(Of _ { Name As String, Phone As Integer } = From c In customers _ Where C.State == "WA _ Select c.Name, c.Phone Dim Joe As Person = New With { _.Name = Joe,.Age = 42, _ Address With { _.Street = 1th St,.City = Seattle } } In Visual Basic 9 Anonymous types Syntax new

39. Dim S1 As String? = Nothing Dim S2 As String? = Hello Dim S3 = S1+S2 Nullable Null propagating + In VB Nothing is default

40. XML DOM Dim PO As New XmlDocument Dim purchaseOrder As XmlElement = _ PO.CreateElement("purchaseOrder") PO.AppendChild(purchaseOrder) Dim orderDate As XmlAttribute = PO.CreateAttribute("orderDate") orderDate.Value = "1999-10-20" purchaseOrder.Attributes.Append(orderDate) Dim shipTo As XmlElement = PO.CreateElement("shipTo") purchaseOrder.AppendChild(shipTo) Dim country As XmlAttribute = PO.CreateAttribute("country") country.Value = "US" shipTo.Attributes.Append(country) What does this program do?

41. Dim Item = _ New XElement("item", _ New XAttribute("partNum", "926-AA"), _ New XElement("productName", …"), _ New XElement("quantity", 1), _ New XElement("price", 39.98), _ New XElement("shipDate", "1999-05-21")))) Functional (expression- based) construction Context-free (no document scope) Simple XLinq API

42. table :: TABLE table = cells :: [[(Int,Int)]] cells = [[ (x,y) | x <- [1..16] ] | y <- [1..16] ] mkRows :: [[(Int,Int)]] -> [TR] mkRows = map $ \cs -> mkColumns :: [(Int,Int)] -> [TD] mkColums = map $ \c -> Haskell Server Pages XHTML Literals (1998) ASP-style embedding Translated to universal DOM representation

43. Dim PO = Alice Smith 123 Maple Street Mill Valley CA 90952 <%= Select > From O In Orders Where O.Name = "Robert Smith" %> Translated to XLinq constructor calls ASP-style embedding Includes full namespace support

44. Late binding over XML Child axis BillTo. BillTo.Elements(street) Attribute axis BillTo.@country BillTo.Attributes(country) Descendants axis PO... PO.Descendants(item)

45. Tools & IDE Type system & Language extensions Runtime & Library support Transactions everywhere Tesla

46. VB IsNot C# VB = static typing where possible, dynamic typing where necessary. Conclusion