1. intro
1.1 'what is' about Dylan
1.1.1 What is Dylan? A imperative, functional and OOP language
1.1.1.1 short definition of imperative, functional and OOP languages with Dylan examples
1.1.1.2 functional view
1.1.1.2.1 the usefulnes of functional programming
1.1.1.2.2 Should Dylan show up in this list of functional languages?
1.1.1.2.3 Learning the Functional Programming paradigma first?
1.1.1.2.4 Please define lambda expression
1.1.1.3 OOP view
1.1.1.3.1 Dylan's Generic Function system
1.1.2 What is Dylan's different world view?
1.1.3 What is out standing about Dylan?
1.1.4 What is Dylan? A language list description.
1.1.5 What is Dylan? Carefully designed
1.1.6 What is Dylan future?
1.1.6.1 Hopes
1.1.6.2 Worries
1.2 'what is not' about Dylan
1.2.1 Dylan is not Lisp
1.2.2 Dylan is not designed for "Hello world" apps
1.3 how to help newcomers to get the right "mental models?
1.3.1 What is the core feature of Dylan? Object-oriented function calls, not objects
1.3.1.1 paradigma shift side notes
1.3.2 Dylan language design principles
1.3.2.1 Syntax: The Dylan Decision
1.3.2.2 provide abstraction facilities as well as performance
1.3.2.3 readability before writability
1.3.2.4 flexibility versus deliverability
1.3.2.5 syntax
1.3.2.5.1 Designed for large blocks of code with really-long-variable-names
1.3.2.5.2 Designed with infix syntax to reach the mainstream
1.3.2.6 Break basic things up into libraries
1.3.2.7 early error detection
1.3.2.8 Slot access is exactly the same as function call
1.3.2.9 "call by value"-semantic
1.3.3 Is Dylan complex?
1.3.4 What is a OODL ( OO Dynamic Language)?
1.3.5 What metal leaps are required
1.3.5.1 from variables-in-c to variables-in-dylan; from pointer reference to object reference
1.3.5.2 Am I a backwards thinker, with my brain stuck in C mode?
1.3.5.3 How to do the mental gear shift single-dispatch OOP to multi method dispatch?
1.3.6 What are the key aspects during the design of Dylan?
1.3.7 What is your background?
1.4 things I like most about Dylan
1.4.1 the balance
1.4.2 no reason for programmers to know how any particular implementation
1.4.3 ability to pass methods, functions, and classes around as first class objects
1.4.4 OS Versions
1.4.4.1 libraries are packaged as DLL's
2. program control
2.1 multi-value binds
2.1.1 How are local multi-value-bind's done in Common Lisp and Dylan?
2.1.2 How are module multi-value-bind's done?
2.1.3 How are multi-values return by a method?
2.1.4 how to capture an unknown number of multiple return values into a sequence?
2.2 control flow
2.2.1 continuations
2.2.1.1 The exit-variable of a block is bound to a continuation
2.2.1.2 Dylan restricts the use of contiuations compared to Scheme
2.2.2 evaluation
2.2.3 iteration
2.2.3.1 via for macro
3. concept
3.1 binding
3.1.1 to do
3.1.2 Binding and Scoping
3.1.3 There is *no* global namespace in Dylan
3.1.4 module binding
3.1.4.1 what's the inverse of 'define variable ' and 'define method' ?
3.1.5 local binding
3.1.5.1 Why is 'let' allowed to float around?
3.1.6 dynamic binding
3.1.7 syntax
3.1.7.1 Talking about let using "=" while assignment uses ":="
3.1.7.2 The syntax for global and local definitions
3.2 libraries and modules
3.2.1 The style of the object model: Not a the class, but module is the namespace generating element
3.2.2 Why aren't the "define module" declarations nested within the "define library" ones?
3.2.3 What does a module system? Provide an elegant namespace management.
3.2.4 Would type signature be an improvement for the module system?
3.2.5 scoping
3.2.5.1 How does a client handle scoping clashes?
3.2.5.2 How a coder prevent scoping clashes?
3.3 types and classes
3.3.1 types
3.3.1.1 some types are not classes in Dylan
3.3.1.2 general
3.3.1.2.1 Does Dylan have a type protocoll?
3.3.1.2.2 Why no null?
3.3.1.3 limited types
3.3.1.3.1 the 'limited' operation: Grasp the various integer meanings.
3.3.1.3.2 limited types
3.3.1.4 instantiable types
3.3.1.4.1 What types are instantiable?
3.3.1.4.2 Who can create new instantiable types?
3.3.2 classes and slots
3.3.2.1 Exploring the difference between the Dylan model and other OO models.
3.3.2.1.1 The object no longer encapsulates the message, that's done by the module.
3.3.2.1.2 How are instance variables accessed
3.3.2.1.3 classes are not namespaces;
3.3.2.2 Features of Classes
3.3.2.2.1 abstract or concrete
Why using open abstract and sealed concrete in one class hierarchy?
Abstract and instantiable Class are separate concepts in Dylan
3.3.2.2.2 primary or free
How to use the primary declaration effectively?
3.3.2.2.3 sealed or open
What's a sealed class
3.3.2.2.4 instantiable or uninstantiable
3.3.2.3 Creating Classes
3.3.2.3.1 Can you mutate an object from one class to another?
3.3.2.3.2 Creating classes at runtime
3.3.2.3.3 What is the language mechanism for specifying the default concrete class for an abstract class?
3.3.2.4 Initialize Classes
3.3.2.5 No Incremental Class Modifications
3.3.2.6 Introspecting Classes
3.3.2.7 about slots
3.3.2.7.1 general
Can one add slots to a class a runtime?
How to generate object methods with the same name? or Remember that slots in Dylan are really just generic functions
3.3.2.7.2 dot syntax
How works a slot reference?
what you should know
3.3.2.7.3 Slot allocation
How to implement the each-subclass slot allocation?
Is there away to access "class allocated" slots without having an instance of that class?
3.3.2.7.4 Slot initialization
How defaulting #"default" to a value?
Slot init value
3.3.2.7.5 Slot inheritance
Retyping inherited slots?
3.4 functions
3.4.1 general
3.4.1.1 Generic Functions
3.4.1.1.1 What does generic mean ?
3.4.1.1.2 What's a generic function?
3.4.1.1.3 Where can I read up more of generic function implementation?
3.4.1.1.4 what generic function gets defined by default as I define methods
3.4.1.1.5 A generic function can act on different (required) objects, but still using different number of optional parameters
3.4.1.2 Methods
3.4.1.2.1 Closure
Discussing the DRM closure example
making two function: fetcher and incrementer
Closures form the backbone
In languages without closures ...
3.4.1.3 Parameter Lists
3.4.1.3.1 Specializing Required Parameters
Convient syntax for singleton specializers
3.4.1.3.2 Keyword Parameters
What are keyword parameters?
Specialised keyword parameters
3.4.1.4 Method Dispatch
3.4.1.4.1 Basic
3.4.1.4.2 multi-method design
3.4.1.4.3 Dylan's Dispatching System is type based
3.4.1.4.4 Dylan's Dispatching System is inheritance based
next-method
3.4.1.4.5 method precedence rules are non-lexicographic
3.4.2 pragmatic
3.4.2.1 Have you to define (+ <int> <real>) and (+ <real> <int>) separately?
3.4.2.2 convention
3.4.2.2.1 ! operations
3.4.2.2.2 immutable syntax vs. ! convention
3.4.3 built-in-function
3.4.3.1 coercion function "as"
3.4.3.2 higher-order functions
3.4.3.2.1 apply
3.4.3.2.2 curry
3.4.3.2.3 reduce
3.4.3.2.4 map
3.5 collection
3.5.1 table
3.5.1.1 How to write your own <table> implementation
3.5.1.2 changing comparator for <table>?
3.5.1.3 Changed the table-protocol?
3.5.2 sequence
3.5.2.1 list
3.5.2.1.1 What does the term "dotted list" mean?
3.5.2.1.2 How to find a specific item in a collection
3.5.2.2 array
3.5.2.2.1 vector
limited <stretchy-vector>
How to subclass vector
3.5.2.3 set
3.5.2.3.1 Q: sets in Dylan
3.5.3 limited collection
3.5.3.1 modify an existing API to use limited collections instead of "regular" collections, you'll break clients.
3.5.4 general
3.5.4.1 Discussing the remove contract
3.5.4.2 Explaining ! operation. Example: reverse!
3.5.4.3 Annotations to collection specification required
3.5.4.4 Creating a New Collection
3.5.4.5 How to find a collection entry with a specific value?
3.5.4.6 How to retrieve an entry based on some specific value or a passed predicate?
3.5.4.7 How does one walk over the keys-and-values of an explicit key collection?
3.5.4.8 #f to mean no object prepares a confusion. How to implement a <empty-object>?
3.5.5 iteration
3.5.5.1 Prefer collection iteration to indexing
3.5.5.2 when to use a iteration protocoll
3.5.5.3 i just don't get iteration
3.5.6 others
3.5.6.1 map-as: Pleasant version
3.6 dynamic
3.6.1 in what way is Dylan dynamic
3.6.2 dynamic loading
3.6.2.1 How to use the ability to dynamically load code from a DLL at run time
3.6.2.2 Binary modularity of dylan Libs
3.6.3 dynamic code generating
3.6.4 dynamic persistency
3.6.5 dynamic typing
3.6.6 dynamic languages
3.6.6.1 dynamic language
3.7 exceptions
3.7.1 intro
3.7.1.1 A view on the mechanism
3.7.1.2 The practical side of things
3.7.1.2.1 step-by-step explaination
3.7.2 general
3.7.2.1 see "Exception" chapter of DP
3.7.2.2 Exceptions by Design: ANSI Standard Exception Handling. The Smalltak Approach
3.7.3 restart
3.7.3.1 Restarts in Dylan
3.7.3.2 the neat part: you can retrofit <restart>s onto an existing API
3.7.4 types
3.7.4.1 violating the contract of a function
3.7.4.2 violating the type constraint on a slot or variable
3.7.4.3 accessing an uninitialized slot
3.8 sealing
3.8.1 Overview
3.8.1.1 What's the goal?
3.8.1.2 What's the rationale for method sealing via the "seal?
3.8.2 Explicitly Known Objects
3.8.3 Declaring Characteristics of Classes
3.8.4 Declaring Characteristics of Generic Functions
3.8.5 Define Sealed Domain
3.8.5.1 Explaining: "Implied Restrictions on Method Definitions"
3.8.5.2 sealed domains
3.9 macros
3.9.1 Semantic of "?="
3.9.2 tutorial
3.9.3 with-each-line
3.9.4 Extensible syntax
3.9.5 facilities
3.9.6 guidelines for writing good macros
3.9.7 pattern variable coercion
3.9.8 Why macros
3.9.8.1 syntactic burden of lambdas
3.9.8.2 Allow to implement application logic in a domain-specific language
3.9.9 Dylan macros are hygenic
3.9.9.1 What are hygenic macros
3.9.9.2 How to do a non-hygenic reference
3.9.10 Why couldn't a parser expand a macro as soon as it saw the ending token?
3.9.11 Wildcard patterns
3.9.12 The ultimate abstraction
3.9.13 examples
3.9.13.1 typical function macros
3.9.13.1.1 Swaping the contents of two places
3.9.13.1.2 Incrementing a place
3.9.13.1.3 Returning the least of its arguments. (This macro uses the wildcard constraint to pass in multiple others)
3.9.13.2 typical "begin word" macros
3.9.13.2.1 with-stack-list to indicate that a list has dynamic extent
3.9.13.2.2 with-stack-vector to indicate that a vector has dynamic extent
3.9.13.2.3 fluid-binding that isn't thread-safe
3.9.13.2.4 destructuring-let simulates CL's 'destructuring-bind'
3.9.13.3 typical "define word" macros
3.9.13.3.1 named-color
3.9.13.3.2 destructuring-let simulates CL's 'destructuring-bind'
3.9.13.3.3 destructuring-let simulates CL's 'destructuring-bind'
3.9.13.3.4 Hairy one that defines a class with slots and some methods
3.9.14 What a competent macro designer must know
3.10 metaobject protocoll (MOP)
3.11 multi inheritance (MI)
3.11.1 What MI is in C++ and What MI is in Dylan (CLOS or whatever)
3.11.2 benefit example
3.11.2.1 code for an user interface toolkit
3.12 introspection
3.12.1 What when i want to know what methods my class supports?
3.13 syntax
3.13.1 let readers view a program either in the Lisp-like surface syntax or in some infix syntax. An approach which got lost along the way to Dylan
3.13.2 changing the syntax is possible
3.13.3 opinions
3.13.3.1 Why the Dylan syntax is different to C/C++ and Algol
3.13.3.2 syntax opinions: an impression
3.13.3.3 What is often misunderstood about the use of 'begin'
4. developing process
4.1 interactivity
4.1.1 Exploring multi-value-bindings in the Dylan Playground
4.1.2 interactivity as language feature
4.2 incremental compilation
4.3 remote debugging
4.4 performance
4.4.1 What feature support optimization?
4.4.1.1 primary classes
4.4.2 Is there any Dylan implementation with a GC good enough for *soft* real-time use
4.4.3 for benchmarking use concrete types
4.4.4 What kind of effect does generic dispatch have on performance?
4.4.5 improves the performance of object creation
4.5 maintainability
4.5.1 readability simplifies maintainability
4.5.2 How do you build a reliable (and easily maintainable) distributed program in presence of generic dispatch anyway?
About
Title
DylanTalks
Subject
-
Company
-
Author
-
Version
141
Comments
-