Lazy initialization

<h2 id="the-lazy-factory">The "lazy factory"</h2>
<p>In a <a href="/facts/Software_design_pattern/mV7r4egw">software design pattern</a> view, lazy initialization is often used together with a <a href="/facts/Factory_method_pattern/frh0TknQ">factory method pattern</a>. This combines three ideas:
</p>
<ul><li>Using a factory method to create instances of a <a href="/facts/Class_(computer_programming)/zvzkSAtE">class</a> (<a href="/facts/Factory_method_pattern/frh0TknQ">factory method pattern</a>)</li>
<li>Storing the instances in a <a href="/facts/Associative_array/IFGd2xcP">map</a>, and returning the <i>same</i> instance to each request for an instance with <i>same</i> parameters (<a href="/facts/Multiton_pattern/QNREgLkx">multiton pattern</a>)</li>
<li>Using lazy initialization to instantiate the object the first time it is requested (lazy initialization pattern)</li></ul>
<h2 id="examples">Examples</h2>
<h3>ActionScript 3</h3>
<p>The following is an example of a class with lazy initialization implemented in <a href="/facts/ActionScript/xtDQb0wR">ActionScript</a>:
</p>
package examples.lazyinstantiation
{
	public class Fruit 
	{
		private var _typeName:String;
		private static var instancesByTypeName:Dictionary = new Dictionary();
	 
		public function Fruit(typeName:String):void
		{
			this._typeName = typeName;
		}
		
		public function get typeName():String 
		{
			return _typeName;
		}
	 
		public static function getFruitByTypeName(typeName:String):Fruit
		{
			return instancesByTypeName[typeName] ||= new Fruit(typeName);
		}
	 
		public static function printCurrentTypes():void
		{
			for each (var fruit:Fruit in instancesByTypeName) 
			{
				// iterates through each value
				trace(fruit.typeName);
			}
		}
	}
}

<p>Basic use:
</p>
package
{
	import examples.lazyinstantiation;
	
	public class Main 
	{
		public function Main():void
		{
			Fruit.getFruitByTypeName("Banana");
			Fruit.printCurrentTypes();
	 
			Fruit.getFruitByTypeName("Apple");
			Fruit.printCurrentTypes();
	 
			Fruit.getFruitByTypeName("Banana");
			Fruit.printCurrentTypes();
		}
	}
}

<h3>C</h3>
<p>In <a href="/facts/C_(programming_language)/Ky2No763">C</a>, lazy evaluation would normally be implemented inside one function, or one source file, using <a href="/facts/Static_variable/dYIs2E5p">static variables</a>.
</p><p>In a function:
</p>
#include <string.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>

struct fruit {
    char *name;
    struct fruit *next;
    int number;
    /* Other members */
};

struct fruit *get_fruit(char *name) {
    static struct fruit *fruit_list;
    static int seq;
    struct fruit *f;
    for (f = fruit_list; f; f = f->next)
        if (0 == strcmp(name, f->name))
            return f;
    if (!(f = malloc(sizeof(struct fruit))))
        return NULL;
    if (!(f->name = strdup(name))) {
        free(f);
        return NULL;
    }
    f->number = ++seq;
    f->next = fruit_list;
    fruit_list = f;
    return f;
}

/* Example code */

int main(int argc, char *argv[]) {
    int i;
    struct fruit *f;
    if (argc < 2) {
        fprintf(stderr, "Usage: fruits fruit-name [...]\n");
        exit(1);
    }
    for (i = 1; i < argc; i++) {
        if ((f = get_fruit(argv[i]))) {
            printf("Fruit %s: number %d\n", argv[i], f->number);
        }
    }
    return 0;
}

<p>Using one source file instead allows the state to be shared between multiple functions, while still hiding it from non-related functions.
</p><p>fruit.h:
</p>
#ifndef _FRUIT_INCLUDED_
#define _FRUIT_INCLUDED_

struct fruit {
    char *name;
    struct fruit *next;
    int number;
    /* Other members */
};

struct fruit *get_fruit(char *name);
void print_fruit_list(FILE *file);

#endif /* _FRUIT_INCLUDED_ */

<p>fruit.c:
</p>
#include <string.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include "fruit.h"

static struct fruit *fruit_list;
static int seq;

struct fruit *get_fruit(char *name) {
    struct fruit *f;
    for (f = fruit_list; f; f = f->next)
        if (0 == strcmp(name, f->name))
            return f;
    if (!(f = malloc(sizeof(struct fruit))))
        return NULL;
    if (!(f->name = strdup(name))) {
        free(f);
        return NULL;
    }
    f->number = ++seq;
    f->next = fruit_list;
    fruit_list = f;
    return f;
}

void print_fruit_list(FILE *file) {
    struct fruit *f;
    for (f = fruit_list; f; f = f->next)
        fprintf(file, "%4d  %s\n", f->number, f->name);
}

<p>main.c:
</p>
#include <stdlib.h>
#include <stdio.h>
#include "fruit.h"

<h3>C#</h3>
<p>In .NET Framework 4.0 Microsoft has included a Lazy class that can be used to do lazy loading.
Below is some dummy code that does lazy loading of Class Fruit
</p>
var lazyFruit = new Lazy<Fruit>();
Fruit fruit = lazyFruit.Value;

<p>Here is a dummy example in <a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a>.
</p><p>The Fruit class itself doesn't do anything here, The <a href="/facts/Class_variable/H5b1PUyR">class variable</a> _typesDictionary is a Dictionary/Map used to store Fruit instances by typeName.
</p>
using System;
using System.Collections;
using System.Collections.Generic;

public class Fruit
{
    private string _typeName;
    private static IDictionary<string, Fruit> _typesDictionary = new Dictionary<string, Fruit>();

private Fruit(string typeName)
    {
        this._typeName = typeName;
    }

public static Fruit GetFruitByTypeName(string type)
    {
        Fruit fruit;

if (!_typesDictionary.TryGetValue(type, out fruit))
        {
            // Lazy initialization
            fruit = new Fruit(type);

_typesDictionary.Add(type, fruit);
        }

return fruit;
    }

public static void ShowAll()
    {
        if (_typesDictionary.Count > 0)
        {
            Console.WriteLine("Number of instances made = {0}", _typesDictionary.Count);
            
            foreach (KeyValuePair<string, Fruit> kvp in _typesDictionary)
            {
                Console.WriteLine(kvp.Key);
            }
            
            Console.WriteLine();
        }
    }
    
    public Fruit()
    {
        // required so the sample compiles
    }
}

class Program
{
    static void Main(string[] args)
    {
        Fruit.GetFruitByTypeName("Banana");
        Fruit.ShowAll();

Fruit.GetFruitByTypeName("Apple");
        Fruit.ShowAll();

// returns pre-existing instance from first 
        // time Fruit with "Banana" was created
        Fruit.GetFruitByTypeName("Banana");
        Fruit.ShowAll();

Console.ReadLine();
    }
}

<p>A fairly straightforward 'fill-in-the-blanks' example of a Lazy Initialization design pattern, except that this uses an <a href="/facts/Enumerated_type/oQITgIYb">enumeration</a> for the type
</p>
namespace DesignPatterns.LazyInitialization;

public class LazyFactoryObject
{
    // internal collection of items
    // IDictionary makes sure they are unique
    private IDictionary<LazyObjectSize, LazyObject> _LazyObjectList =
        new Dictionary<LazyObjectSize, LazyObject>();

// enum for passing name of size required
    // avoids passing strings and is part of LazyObject ahead
    public enum LazyObjectSize
    {
        None,
        Small,
        Big,
        Bigger,
        Huge
    }

// standard type of object that will be constructed
    public struct LazyObject
    {
        public LazyObjectSize Size;
        public IList<int> Result;
    }

// takes size and create 'expensive' list
    private IList<int> Result(LazyObjectSize size)
    {
        IList<int> result = null;

switch (size)
        {
            case LazyObjectSize.Small:
                result = CreateSomeExpensiveList(1, 100);
                break;
            case LazyObjectSize.Big:
                result = CreateSomeExpensiveList(1, 1000);
                break;
            case LazyObjectSize.Bigger:
                result = CreateSomeExpensiveList(1, 10000);
                break;
            case LazyObjectSize.Huge:
                result = CreateSomeExpensiveList(1, 100000);
                break;
            case LazyObjectSize.None:
                result = null;
                break;
            default:
                result = null;
                break;
        }

return result;
    }

// not an expensive item to create, but you get the point
    // delays creation of some expensive object until needed
    private IList<int> CreateSomeExpensiveList(int start, int end)
    {
        IList<int> result = new List<int>();

for (int counter = 0; counter < (end - start); counter++)
        {
            result.Add(start + counter);
        }

return result;
    }

public LazyFactoryObject()
    {
        // empty constructor
    }

public LazyObject GetLazyFactoryObject(LazyObjectSize size)
    {
        // yes, i know it is illiterate and inaccurate
        LazyObject noGoodSomeOne;

// retrieves LazyObjectSize from list via out, else creates one and adds it to list
        if (!_LazyObjectList.TryGetValue(size, out noGoodSomeOne))
        {
            noGoodSomeOne = new LazyObject();
            noGoodSomeOne.Size = size;
            noGoodSomeOne.Result = this.Result(size);

_LazyObjectList.Add(size, noGoodSomeOne);
        }

return noGoodSomeOne;
    }
}

<h3>C++</h3>
<p>This example is in <a href="/facts/C%252B%252B/Et0F2qn9">C++</a>.
</p>
import std;

class Fruit {
 public:
  static Fruit* GetFruit(const std::string& type);
  static void PrintCurrentTypes();

private:
  // Note: constructor private forcing one to use static |GetFruit|.
  Fruit(const std::string& type) : type_(type) {}

static std::map<std::string, Fruit*> types;

std::string type_;
};

// static
std::map<std::string, Fruit*> Fruit::types;

// Lazy Factory method, gets the |Fruit| instance associated with a certain
// |type|.  Creates new ones as needed.
Fruit* Fruit::GetFruit(const std::string& type) {
  auto [it, inserted] = types.emplace(type, nullptr);
  if (inserted) {
    it->second = new Fruit(type);
  }
  return it->second;
}

// For example purposes to see pattern in action.
void Fruit::PrintCurrentTypes() {
  std::println("Number of instances made = {}", types.size());
  for (const auto& [type, fruit] : types) {
    std::println({}, type);
  }
  std::println();
}

int main() {
  Fruit::GetFruit("Banana");
  Fruit::PrintCurrentTypes();

Fruit::GetFruit("Apple");
  Fruit::PrintCurrentTypes();

// Returns pre-existing instance from first time |Fruit| with "Banana" was
  // created.
  Fruit::GetFruit("Banana");
  Fruit::PrintCurrentTypes();
}

// OUTPUT:
//
// Number of instances made = 1
// Banana
//
// Number of instances made = 2
// Apple
// Banana
//
// Number of instances made = 2
// Apple
// Banana
//

<h3>Crystal</h3>
class Fruit
  private getter type : String
  @@types = {} of String => Fruit

def initialize(@type)
  end

def self.get_fruit_by_type(type : String)
    @@types[type] ||= Fruit.new(type)
  end

def self.show_all
    puts "Number of instances made: #{@@types.size}"
    @@types.each do |type, fruit|
      puts "#{type}"
    end
    puts
  end

def self.size
    @@types.size
  end
end

Fruit.get_fruit_by_type("Banana")
Fruit.show_all

Fruit.get_fruit_by_type("Apple")
Fruit.show_all

Fruit.get_fruit_by_type("Banana")
Fruit.show_all

<p>Output:
</p>
Number of instances made: 1
Banana

Number of instances made: 2
Banana
Apple

<h3>Haxe</h3>
<p>This example is in <a href="/facts/Haxe/jp87sM7P">Haxe</a>.<a class="footnote-ref" id="fnref:1" href="#fn:1"><sup>1</sup></a>
</p>
class Fruit {
  private static var _instances = new Map<String, Fruit>();

public var name(default, null):String;

public function new(name:String) {
    this.name = name;
  }

public static function getFruitByName(name:String):Fruit {
    if (!_instances.exists(name)) {
      _instances.set(name, new Fruit(name));
    }
    return _instances.get(name);
  }

public static function printAllTypes() {
    trace([for(key in _instances.keys()) key]);
  }
}
<p>Usage</p>class Test {
  public static function main () {
    var banana = Fruit.getFruitByName("Banana");
    var apple = Fruit.getFruitByName("Apple");
    var banana2 = Fruit.getFruitByName("Banana");
    
    trace(banana == banana2); // true. same banana
    
    Fruit.printAllTypes(); // ["Banana","Apple"]
  }
}

<p>This example is in <a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a>.
</p>
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class Program {

/**
     * @param args
     */
    public static void main(String[] args) {
        Fruit.getFruitByTypeName(FruitType.banana);
        Fruit.showAll();
        Fruit.getFruitByTypeName(FruitType.apple);
        Fruit.showAll();
        Fruit.getFruitByTypeName(FruitType.banana);
        Fruit.showAll();
    }
}

enum FruitType {
    none,
    apple,
    banana,
}

class Fruit {

private static Map<FruitType, Fruit> types = new HashMap<>();
    
    /**
     * Using a private constructor to force the use of the factory method.
     * @param type
     */
    private Fruit(FruitType type) {
    }
    
    /**
     * Lazy Factory method, gets the Fruit instance associated with a certain
     * type. Instantiates new ones as needed.
     * @param type Any allowed fruit type, e.g. APPLE
     * @return The Fruit instance associated with that type.
     */
    public static Fruit getFruitByTypeName(FruitType type) {
        Fruit fruit;
                // This has concurrency issues.  Here the read to types is not synchronized, 
                // so types.put and types.containsKey might be called at the same time.
                // Don't be surprised if the data is corrupted.
        if (!types.containsKey(type)) {
            // Lazy initialisation
            fruit = new Fruit(type);
            types.put(type, fruit);
        } else {
            // OK, it's available currently
            fruit = types.get(type);
        }
        
        return fruit;
    }
    
    /**
     * Lazy Factory method, gets the Fruit instance associated with a certain
     * type. Instantiates new ones as needed. Uses double-checked locking 
     * pattern for using in highly concurrent environments.
     * @param type Any allowed fruit type, e.g. APPLE
     * @return The Fruit instance associated with that type.
     */
    public static Fruit getFruitByTypeNameHighConcurrentVersion(FruitType type) {
        if (!types.containsKey(type)) {
            synchronized (types) {
                // Check again, after having acquired the lock to make sure
                // the instance was not created meanwhile by another thread
                if (!types.containsKey(type)) {
                    // Lazy initialisation
                    types.put(type, new Fruit(type));
                }
            }
        }
        
        return types.get(type);
    }
    
    /**
     * Displays all entered fruits.
     */
    public static void showAll() {
        if (types.size() > 0) {
 
           System.out.println("Number of instances made = " + types.size());
            
            for (Entry<FruitType, Fruit> entry : types.entrySet()) {
                String fruit = entry.getKey().toString();
                fruit = Character.toUpperCase(fruit.charAt(0)) + fruit.substring(1);
                System.out.println(fruit);
            }
            
            System.out.println();
        }
    }
}

<p>Output
</p>
Number of instances made = 1
Banana

Number of instances made = 2
Banana
Apple

<h3>JavaScript</h3>
<p>This example is in <a href="/facts/JavaScript/XhhIIEsl">JavaScript</a>.
</p>
var Fruit = (function() {
  var types = {};
  function Fruit() {};

// count own properties in object
  function count(obj) {
    return Object.keys(obj).length;
  }

return _static;

})();

Fruit.getFruit('Apple');
Fruit.printCurrentTypes();
Fruit.getFruit('Banana');
Fruit.printCurrentTypes();
Fruit.getFruit('Apple');
Fruit.printCurrentTypes();

<p>Output
</p>
Number of instances made: 1
Apple

Number of instances made: 2
Apple
Banana

<h3>PHP</h3>
<p>Here is an example of lazy initialization in <a href="/facts/PHP/vU6YRJX0">PHP</a> 7.4:
</p>
<?php
header('Content-Type: text/plain; charset=utf-8');

class Fruit
{
    private string $type;
    private static array $types = array();

private function __construct(string $type)
    {
        $this->type = $type;
    }

public static function getFruit(string $type)
    {
        // Lazy initialization takes place here
        if (!isset(self::$types[$type])) {
            self::$types[$type] = new Fruit($type);
        }

return self::$types[$type];
    }

public static function printCurrentTypes(): void
    {
        echo 'Number of instances made: ' . count(self::$types) . "\n";
        foreach (array_keys(self::$types) as $key) {
            echo "$key\n";
        }
        echo "\n";
    }
}

Fruit::getFruit('Apple');
Fruit::printCurrentTypes();

Fruit::getFruit('Banana');
Fruit::printCurrentTypes();

Fruit::getFruit('Apple');
Fruit::printCurrentTypes();

/*
OUTPUT:

Number of instances made: 1
Apple

Number of instances made: 2
Apple
Banana

Number of instances made: 2
Apple
Banana
*/

<h3>Python</h3>
<p>This example is in <a href="/facts/Python_(programming_language)/YbuGqofa">Python</a>.
</p>
class Fruit:
    def __init__(self, item: str):
        self.item = item
    
class FruitCollection:
    def __init__(self):
        self.items = {}
    
    def get_fruit(self, item: str) -> Fruit:
        if item not in self.items:
            self.items[item] = Fruit(item)
        
        return self.items[item]

if __name__ == "__main__":
    fruits = FruitCollection()
    print(fruits.get_fruit("Apple"))
    print(fruits.get_fruit("Lime"))

<h3>Ruby</h3>
<p>This example is in <a href="/facts/Ruby_(programming_language)/BeYSaPSR">Ruby</a>, of lazily initializing an authentication token from a remote service like Google. The way that @auth_token is cached is also an example of <a href="/facts/Memoization/u08VhUKm">memoization</a>.
</p>
require 'net/http'
class Blogger
  def auth_token
    @auth_token ||=
      (res = Net::HTTP.post_form(uri, params)) &&
      get_token_from_http_response(res)
  end

# get_token_from_http_response, uri and params are defined later in the class
end

b = Blogger.new
b.instance_variable_get(:@auth_token) # returns nil
b.auth_token # returns token
b.instance_variable_get(:@auth_token) # returns token

<h3>Rust</h3>
<p><a href="/facts/Rust_(programming_language)/8JNMV19F">Rust</a> have std::cell::LazyCell.<a class="footnote-ref" id="fnref:2" href="#fn:2"><sup>2</sup></a>
</p>
use std::cell::LazyCell;

let lazy = LazyCell::new(|| 42);

<h3>Scala</h3>
<p><a href="/facts/Scala_(programming_language)/ebL8o6AK">Scala</a> has built-in support for lazy variable initiation.<a class="footnote-ref" id="fnref:3" href="#fn:3"><sup>3</sup></a>
</p>
 scala> val x = { println("Hello"); 99 }
 Hello
 x: Int = 99
 scala> lazy val y = { println("Hello!!"); 31 }
 y: Int = <lazy>
 scala> y
 Hello!!
 res2: Int = 31
 scala> y
 res3: Int = 31

<h3>Smalltalk</h3>
<p>This example is in <a href="/facts/Smalltalk/Ru2UPVDE">Smalltalk</a>, of a typical <a href="/facts/Accessor_method/sKfxYzFM">accessor method</a> to return the value of a variable using lazy initialization.
</p>
    height
        ^height ifNil: [height := 2.0].

<p>The 'non-lazy' alternative is to use an initialization method that is run when the object is created and then use a simpler accessor method to fetch the value.
</p>
    initialize
        height := 2.0

height
        ^height

<p>Note that lazy initialization can also be used in non-<a href="/facts/Object-oriented_language/TxNMEcao">object-oriented languages</a>.
</p>
<h2 id="theoretical-computer-science">Theoretical computer science</h2>
<p>In the field of <a href="/facts/Theoretical_computer_science/jSkGGuvy">theoretical computer science</a>, lazy initialization<a class="footnote-ref" id="fnref:4" href="#fn:4"><sup>4</sup></a> (also called a lazy array) is a technique to design <a href="/facts/Data_structure/yNsNvL1I">data structures</a> that can work with memory that does not need to be initialized. Specifically, assume that we have access to a table <i>T</i> of <i>n</i> uninitialized memory cells (numbered from <i>1</i> to <i>n</i>), and want to assign <i>m</i> cells of this array, e.g., we want to assign <i>T</i>[<i>ki</i>] := <i>vi</i> for pairs (<i>k</i>1, <i>v</i>1), ..., (<i>km</i>, <i>vm</i>) with all <i>ki</i> being different. The lazy initialization technique allows us to do this in just O(<i>m</i>) operations, rather than spending O(<i>m</i>+<i>n</i>) operations to first initialize all array cells. The technique is simply to allocate a table <i>V</i> storing the pairs (<i>ki</i>, <i>vi</i>) in some arbitrary order, and to write for each <i>i</i> in the cell <i>T</i>[<i>ki</i>] the position in <i>V</i> where key <i>ki</i> is stored, leaving the other cells of <i>T</i> uninitialized. This can be used to handle queries in the following fashion: when we look up cell <i>T</i>[<i>k</i>] for some <i>k</i>, we can check if <i>T</i>[<i>k</i>] is in the range {1, ..., <i>m</i>}: if it is not, then <i>T</i>[<i>k</i>] is uninitialized. Otherwise, we check <i>V</i>[<i>T</i>[<i>k</i>]], and verify that the first component of this pair is equal to <i>k</i>. If it is not, then <i>T</i>[<i>k</i>] is uninitialized (and just happened by accident to fall in the range {1, ..., <i>m</i>}). Otherwise, we know that <i>T</i>[<i>k</i>] is indeed one of the initialized cells, and the corresponding value is the second component of the pair.
</p>
<h2 id="see-also">See also</h2>
<ul><li><a href="/facts/Double-checked_locking/VftRmHXu">Double-checked locking</a></li>
<li><a href="/facts/Lazy_loading/BpH8qyWJ">Lazy loading</a></li>
<li><a href="/facts/Proxy_pattern/CHHyzXbd">Proxy pattern</a></li>
<li><a href="/facts/Singleton_pattern/dl70cvTu">Singleton pattern</a></li></ul>

<h2 id="external-links">External links</h2>
<ul><li>Article "<a href="https://www.infoworld.com/article/2077568/java-tip-67--lazy-instantiation.html">Java Tip 67: Lazy instantiation</a> - Balancing performance and resource usage" by Philip Bishop and Nigel Warren</li>
<li><a href="http://javapractices.com/Topic34.cjp">Java code examples</a></li>
<li><a href="https://web.archive.org/web/20191202055631/http://devx.com/tips/Tip/18007">Use Lazy Initialization to Conserve Resources</a></li>
<li><a href="https://wiki.c2.com/?LazyInitialization">Description from the Portland Pattern Repository</a></li>
<li><a href="https://web.archive.org/web/20060911223210/http://weblogs.java.net/blog/binod/archive/2005/09/lazy_initializa.html">Lazy Initialization of Application Server Services</a></li>
<li><a href="https://sourceforge.net/projects/jsiner/">Lazy Inheritance in JavaScript</a></li>
<li><a href="https://kaliko.com/blog/lazy-loading-in-c-net/">Lazy Inheritance in C#</a></li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>"Lazy initialization - Design patterns - Haxe programming language cookbook". 2018-01-11. Retrieved 2018-11-09. <a href="https://code.haxe.org/category/design-patterns/lazy-initialization.html" target="_blank">https://code.haxe.org/category/design-patterns/lazy-initialization.html</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>"LazyCell in std::cell - Rust". doc.rust-lang.org. Retrieved 18 January 2025. <a href="https://doc.rust-lang.org/std/cell/struct.LazyCell.html" target="_blank">https://doc.rust-lang.org/std/cell/struct.LazyCell.html</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
<li id="fn:3"><p>Pollak, David (2009-05-25). Beginning Scala. Apress. ISBN 9781430219897. <a href="9781430219897" target="_blank">9781430219897</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li>
<li id="fn:4"><p>Moret, B. M. E.; Shapiro, H. D. (1991). Algorithms from P to NP, Volume 1: Design & Efficiency. Benjamin/Cummings Publishing Company. pp. 191–192. ISBN 0-8053-8008-6. <a href="0-8053-8008-6" target="_blank">0-8053-8008-6</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li>
</ol>

Lazy initialization open-in-new

Lazy initialization