19.15 Summary

The most important point about performance is that it is important to pay attention to efficiency during the entire design and development cycle of a project. During the design phase, try to ensure that the algorithms chosen have the right asymptotic behavior and constant factors, and that it is possible to implement the needed operations efficiently. During the implementation phase, use the language constructs that most clearly express what the program is doing. Once the program is working correctly, it is then time to add type and sealing declarations, and to use metering and profiling tools to find and rewrite heavily used, slow parts of the program, in order to improve the performance.

One of the most important considerations when programming is not to worry about performance too soon. It is always more important that your design and implementation be clear and correct, first. There is no value in arriving at an answer with lightning speed, if it turns out to be the wrong answer.

In this chapter, we covered the following:

• We showed how Dylan can balance performance and flexibility to support a range of programming requirements.

• We showed how type constraints affect performance.

• We showed how limited types can improve performance.

• We showed how open generic functions provide modularity and flexibility.

• We showed how open classes provide modularity and flexibility.

• We showed how sealed generic function domains mitigate the performance penalty of open classes and generic functions.

• We showed how primary classes permit efficient slot access.

• We presented both an execution and efficiency model that provides a conceptual model of how a program in Dylan runs, and what the relative cost of different program elements are.

• We examined the method constructs for flexibility and performance available in Dylan; see Table 19.1.

Table 19.1 Methods: flexibility versus performance.

Construct	Effects
direct method	highly optimizable no method dispatch
sealed generic function on a sealed class	highly optimizable not extensible by other libraries
sealed generic function on an open class	optimizable other libraries can subclass
open generic function on an open class in a sealed domain	highly optimizable other libraries can add methods other libraries can subclass
open generic function on an open class	not optimizable methods can be added at run time subclasses can be created at run time

• We discussed the constructs that can have type constraints, and the influence on performance or flexibility of using such a declaration; see Table 19.2.

Table 19.2 Type constraint: flexibility versus performance.

Construct	Effects
module constants	enforce program correctness
module variables	permit type inferencing
required parameters	required for method dispatch permit type inferencing
optional parameters	permit type inferencing
return values	enforce program correctness permit type inferencing
limited types	permit type inferencing permit compact data representation
slots	permit type inferencing