Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2010/ch7 7g ms

2010-12-01T20:57:58Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch7 7g ms

2010-12-01T20:57:36Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch7 7g ms

2010-12-01T20:57:10Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch7 7g ms

2010-12-01T20:56:08Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch7 7g ms

2010-12-01T20:53:04Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch7 7g ms

2010-12-01T20:52:30Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch7 7g ms

2010-12-01T20:51:49Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch7 7g ms

2010-12-01T20:49:48Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch7 7g ms

2010-12-01T20:48:33Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch7 7g ms

2010-12-01T20:48:01Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch7 7g ms

2010-12-01T20:47:09Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch7 7g ms

2010-12-01T20:46:36Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch7 7g ms

2010-12-01T20:44:41Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch7 7g ms

2010-12-01T20:44:13Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch7 7g ms

2010-12-01T20:37:45Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch7 7g ms

2010-12-01T20:28:53Z

Mlsurrat:

'''Analysis Paralysis Anti-Pattern'''

=Analysis Paralysis Anti-pattern=

In software engineering, an anti-pattern (or antipattern) is a pattern that may be commonly used but is ineffective and/or counterproductive in practice.

In analysis paralysis, we over analyze (or over think) a situation until no decision is ever made, which effectively paralyzes the current process' outcome.

===Class Diagram===
[[Image:IC73826.gif|500px|center]]

This diagram is a Universal Modeling Languages (UML) diagram of how a Singleton class would look if implemented in Java.
===Sequence Diagram===
[[Image:CR2.gif|500px|center]]
This diagram illustrates how the Singleton class creates an instance of the Singleton object. The client classes then create instances of the Singleton class which handles access to the Singleton object.

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects. [[#References|[1]]]

==Creating the instance==
===Early Instantiation===
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.
===Late Instantiation===
The instance of the class can be created after class loading. (See the C++ example) This can be done by only allocating the instance on the first access of the instance variable.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.
<pre>
private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}
</pre>
[[#References|[1]]]

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope. [[#References|[6]]]

<pre>
class genericFactory
include Singleton
end
</pre>
[[#References|[1]]]

<pre>
class Logger
def initialize
@log = File.open("log.txt", "a")
end

@@instance = Logger.new

def self.instance
return @@instance
end

def log(msg)
@log.puts(msg)
end

private_class_method :new
end

Logger.instance.log('message 1')

</pre>
[[#References|[6]]]

==C++==
<pre>
// Declaration
class Singleton {
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}
</pre>
[[#References|[3]]]

=Benefits=

*This pattern allows the programmer to control the instances of a particular object, it ensures that all objects use the same instance of a class.[[#References|[3]]]

*The Singleton class has the ability to control the instantiation process since it implements the instantiation functionality.[[#References|[3]]]

=Drawbacks=

*Unit tests are much harder to write when using the Singleton pattern.[[#References|[3]]]

*This pattern reduces the potential for parallelism within a program since the threads must be serialized.[[#References|[3]]]

*The overhead of checking whether there is an instance of a class that already exists every time an objects requests a reference. Although the overhead is minuscule, this could be a serious problem for systems which don't have the resources to waste. [[#References|[3]]]

*There may be some development confusion with implementing the singleton class (especially one defined in a class library) because developers may forget that they cannot use the "new" keyword to instantiate the object.[[#References|[3]]]

*The singleton design pattern doesn't address the issue of deleting the single object. Some languages implement memory management which means that the Singleton class can only be unallocated by itself since it holds a private reference to the instance of itself. In languages that don't provide memory management, then the single instance can be deleted but it will cause a dangling reference to that object.[[#References|[3]]]

=References=

[[#References|[1]]] Wikipedia. (2010, October) Wikipedia - Singleton_Pattern. [Online]. http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way

[[#References|[2]]] Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. (October 2004) Head First design patterns. [Print.]

[[#References|[3]]] C# Corner (2010, October) Creational Patterns - Singleton. [Online]. http://www.c-sharpcorner.com/UploadFile/susanabraham/CreationalPatterns06042005050058AM/CreationalPatterns.aspx

[[#References|[4]]] Source Making (2010, October) Singleton Design Pattern. [Online]. http://sourcemaking.com/design_patterns/singleton

[[#References|[5]]] JavaBeginner.com (2010, October) Java Singleton Design Pattern. [Online]. http://www.javabeginner.com/learn-java/java-singleton-design-pattern

[[#References|[6]]] Dalibor Nasevic (2010, October) Ruby Singleton Pattern Again. [Online]. http://dalibornasevic.com/posts/9-ruby-singleton-pattern-again

CSC/ECE 517 Fall 2010/ch1 S10 ms

2010-12-01T19:57:28Z

Mlsurrat:

*[[CSC/ECE 517 Fall 2010/ch1 1a vc]]

*[[CSC/ECE 517 Fall 2010/ch1 1a br]]

*[[CSC/ECE 517 Fall 2010/ch1 1b mg]]

*[[CSC/ECE 517 Fall 2010/ch1 1c JF]]

*[[CSC/ECE 517 Fall 2010/ch1 1e az]]

*[[CSC/ECE 517 Fall 2010/ch1 1e bb]]

*[[CSC/ECE 517 Fall 2010/ch1 1f vn]]

*[[CSC/ECE 517 Fall 2010/ch1 25 ag]]

*[[CSC/ECE 517 Fall 2010/ch2 2b dg]]

*[[CSC/ECE 517 Fall 2010/ch1 2e RI]]

*[[CSC/ECE 517 Fall 2010/ch1 S6 aa]]

*[[CSC/ECE 517 Fall 2010/ch1 S6 km]]

*[[CSC/ECE 517 Fall 2010/ch1 S10 GP]]

*[[CSC/ECE 517 Fall 2010/ch1 S10 MS]]

*[[CSC/ECE 517 Fall 2010/ch1 S10 MM]]

*[[CSC/ECE 517 Fall 2010/ch1 S10 PH]]

*[[CSC/ECE 517 Fall 2010/ch2 2a CB]]

*[[CSC/ECE 517 Fall 2010/ch2 2a mw]]

*[[CSC/ECE 517 Fall 2010/ch2 2c ck]]

*[[CSC/ECE 517 Fall 2010/ch2 S23 GP]]

*[[CSC/ECE 517 Fall 2010/ch2 S24 NS]]

*[[CSC/ECE 517 Fall 2010/ch2 S23 SS]]

*[[CSC/ECE 517 Fall 2010/ch2 S23 NR]]

*[[CSC/ECE 517 Fall 2010/ch2 S20 TT]]

*[[CSC/ECE 517 Fall 2010/ch2 2d AS]]

*[[CSC/ECE 517 Fall 2010/ch2 S24 rm]]

*[[CSC/ECE 517 Fall 2010/ch3 3a SN]]

*[[CSC/ECE 517 Fall 2010/ch3 3b ka]]

*[[CSC/ECE 517 Fall 2010/ch3 3e br]]

*[[CSC/ECE 517 Fall 2010/ch3 3f lj]]

*[[CSC/ECE 517 Fall 2010/ch3 3h az]]

*[[CSC/ECE 517 Fall 2010/ch3 3h PW]]

*[[CSC/ECE 517 Fall 2010/ch3 3i IC]]

*[[CSC/ECE 517 Fall 2010/ch3 3i MM]]

*[[CSC/ECE 517 Fall 2010/ch3 3j KS]]

*[[CSC/ECE 517 Fall 2010/ch3 S30 SK]]

*[[CSC/ECE 517 Fall 2010/ch3 4b mt]]

*[[CSC/ECE 517 Fall 2010/ch4 4e ms]]

*[[CSC/ECE 517 Fall 2010/ch4 4f sv]]

*[[CSC/ECE 517 Fall 2010/ch4 4g HW]]

*[[CSC/ECE 517 Fall 2010/ch4 4g km]]

*[[CSC/ECE 517 Fall 2010/ch4 4h am]]

*[[CSC/ECE 517 Fall 2010/ch5 5b mt]]

*[[CSC/ECE 517 Fall 2010/ch5 5b jz]]

*[[CSC/ECE 517 Fall 2010/ch5 5c ck]]

*[[CSC/ECE 517 Fall 2010/ch5 5c IC]]

*[[CSC/ECE 517 Fall 2010/ch5 5f SN]]

*[[CSC/ECE 517 Fall 2010/ch5 5a KR]]

*[[CSC/ECE 517 Fall 2010/ch5 5b RR]]

*[[CSC/ECE 517 Fall 2010/ch5 5e ms]]

*[[CSC/ECE 517 Fall 2010/chd 6d isb]]

*[[CSC/ECE 517 Fall 2010/ch6 6b SK]]

*[[CSC/ECE 517 Fall 2010/ch6 6c AW]]

*[[CSC/ECE 517 Fall 2010/ch6 6d bb]]

*[[CSC/ECE 517 Fall 2010/ch6 6h AS]]

*[[CSC/ECE 517 Fall 2010/ch6 6f AZ]]

*[[CSC/ECE 517 Fall 2010/ch6 6b AK]]

*[[CSC/ECE 517 Fall 2010/ch6 6g ss]]

*[[CSC/ECE 517 Fall 2010/ch6 6d NM]]

*[[ CSC/ECE 517 Fall 2010/ch6 6a PC]]

*[[ CSC/ECE 517 Fall 2010/ch2 4d RB]]

*[[ CSC/ECE 517 Fall 2010/ch7 7e GP]]

*[[ CSC/ECE 517 Fall 2010/ch7 7f PW]]

*[[ CSC/ECE 517 Fall 2010/ch7 7g ms]]

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-14T02:28:59Z

Mlsurrat:

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=

A [http://en.wikipedia.org/wiki/Design_pattern_%28computer_science%29|[design pattern]], like singleton, is a way for a software developer to handle situations using a known solution that has been proven to be effective in the past. Design patterns also make communicating ideas and concepts between programmers more efficient and understandable.

In the Singleton design pattern we create a single instance of a Singleton class. Any instantiation of that Singleton class references the same instance of the class. The pattern also provides a global point of access for the functionality contained in the sole instance of the class.

===Class Diagram===
[[Image:IC73826.gif|500px|center]]

This diagram is a Universal Modeling Languages (UML) diagram of how a Singleton class would look if implemented in Java.
===Sequence Diagram===
[[Image:CR2.gif|500px|center]]
This diagram illustrates how the Singleton class creates an instance of the Singleton object. The client classes then create instances of the Singleton class which handles access to the Singleton object.
=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects. [[#References|[1]]]

==Creating the instance==
===Early Instantiation===
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.
===Late Instantiation===
The instance of the class can be created after class loading. (See the C++ example) This can be done by only allocating the instance on the first access of the instance variable.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.
<pre>
private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}
</pre>
[[#References|[1]]]

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope. [[#References|[6]]]

<pre>
class genericFactory
include Singleton
end
</pre>
[[#References|[1]]]

<pre>
class Logger
def initialize
@log = File.open("log.txt", "a")
end

@@instance = Logger.new

def self.instance
return @@instance
end

def log(msg)
@log.puts(msg)
end

private_class_method :new
end

Logger.instance.log('message 1')

</pre>
[[#References|[6]]]

==C++==
<pre>
// Declaration
class Singleton {
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}
</pre>
[[#References|[3]]]

=Benefits=

*This pattern allows the programmer to control the instances of a particular object, it ensures that all objects use the same instance of a class.[[#References|[3]]]

*The Singleton class has the ability to control the instantiation process since it implements the instantiation functionality.[[#References|[3]]]

=Drawbacks=

*Unit tests are much harder to write when using the Singleton pattern.[[#References|[3]]]

*This pattern reduces the potential for parallelism within a program since the threads must be serialized.[[#References|[3]]]

*The overhead of checking whether there is an instance of a class that already exists every time an objects requests a reference. Although the overhead is minuscule, this could be a serious problem for systems which don't have the resources to waste. [[#References|[3]]]

*There may be some development confusion with implementing the singleton class (especially one defined in a class library) because developers may forget that they cannot use the "new" keyword to instantiate the object.[[#References|[3]]]

*The singleton design pattern doesn't address the issue of deleting the single object. Some languages implement memory management which means that the Singleton class can only be unallocated by itself since it holds a private reference to the instance of itself. In languages that don't provide memory management, then the single instance can be deleted but it will cause a dangling reference to that object.[[#References|[3]]]

=References=

[[#References|[1]]] Wikipedia. (2010, October) Wikipedia - Singleton_Pattern. [Online]. http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way

[[#References|[2]]] Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. (October 2004) Head First design patterns. [Print.]

[[#References|[3]]] C# Corner (2010, October) Creational Patterns - Singleton. [Online]. http://www.c-sharpcorner.com/UploadFile/susanabraham/CreationalPatterns06042005050058AM/CreationalPatterns.aspx

[[#References|[4]]] Source Making (2010, October) Singleton Design Pattern. [Online]. http://sourcemaking.com/design_patterns/singleton

[[#References|[5]]] JavaBeginner.com (2010, October) Java Singleton Design Pattern. [Online]. http://www.javabeginner.com/learn-java/java-singleton-design-pattern

[[#References|[6]]] Dalibor Nasevic (2010, October) Ruby Singleton Pattern Again. [Online]. http://dalibornasevic.com/posts/9-ruby-singleton-pattern-again

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-14T02:20:36Z

Mlsurrat:

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=

In the Singleton design pattern we create a single instance of a Singleton class. Any instantiation of that Singleton class references the same instance of the class. The pattern also provides a global point of access for the functionality contained in the sole instance of the class. A design pattern is a way for a software developer to handle situations using a known solution that has been proven to be effective in the past. Design patterns also make communicating ideas and concepts between programmers more efficient and understandable.

===Class Diagram===
[[Image:IC73826.gif|500px|center]]

This diagram is a Universal Modeling Languages (UML) diagram of how a Singleton class would look if implemented in Java.
===Sequence Diagram===
[[Image:CR2.gif|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects. [[#References|[1]]]

==Creating the instance==
===Early Instantiation===
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.
===Late Instantiation===
The instance of the class can be created after class loading. This can be done by only allocating the instance on the first access of the instance variable.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.
<pre>
private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}
</pre>
[[#References|[1]]]

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

<pre>
class genericFactory
include Singleton
end
</pre>
[[#References|[1]]]

<pre>
class Logger
def initialize
@log = File.open("log.txt", "a")
end

@@instance = Logger.new

def self.instance
return @@instance
end

def log(msg)
@log.puts(msg)
end

private_class_method :new
end

Logger.instance.log('message 1')

</pre>
[[#References|[6]]]

==C++==
<pre>
// Declaration
class Singleton {
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}
</pre>
[[#References|[3]]]

=Benefits=

*This pattern allows the programmer to control the instances of a particular object, it ensures that all objects use the same instance of a class.[[#References|[3]]]

*The Singleton class has the ability to control the instantiation process since it implements the instantiation functionality.[[#References|[3]]]

=Drawbacks=

*Unit tests are much harder to write when using the Singleton pattern.[[#References|[3]]]

*This pattern reduces the potential for parallelism within a program since the threads must be serialized.[[#References|[3]]]

*The overhead of checking whether there is an instance of a class that already exists every time an objects requests a reference. Although the overhead is minuscule, this could be a serious problem for systems which don't have the resources to waste. [[#References|[3]]]

*There may be some development confusion with implementing the singleton class (especially one defined in a class library) because developers may forget that they cannot use the "new" keyword to instantiate the object.[[#References|[3]]]

*The singleton design pattern doesn't address the issue of deleting the single object. Some languages implement memory management which means that the Singleton class can only be unallocated by itself since it holds a private reference to the instance of itself. In languages that don't provide memory management, then the single instance can be deleted but it will cause a dangling reference to that object.[[#References|[3]]]

=References=

[[#References|[1]]] Wikipedia. (2010, October) Wikipedia - Singleton_Pattern. [Online]. http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way

[[#References|[2]]] Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. (October 2004) Head First design patterns. [Print.]

[[#References|[3]]] C# Corner (2010, October) Creational Patterns - Singleton. [Online]. http://www.c-sharpcorner.com/UploadFile/susanabraham/CreationalPatterns06042005050058AM/CreationalPatterns.aspx

[[#References|[4]]] Source Making (2010, October) Singleton Design Pattern. [Online]. http://sourcemaking.com/design_patterns/singleton

[[#References|[5]]] JavaBeginner.com (2010, October) Java Singleton Design Pattern. [Online]. http://www.javabeginner.com/learn-java/java-singleton-design-pattern

[[#References|[6]]] Dalibor Nasevic (2010, October) Ruby Singleton Pattern Again. [Online]. http://dalibornasevic.com/posts/9-ruby-singleton-pattern-again

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-14T02:10:26Z

Mlsurrat: /* Defintions */

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=
In the Singleton design pattern we create a single instance of a Singleton class. Any instantiation of that Singleton class references the same instance of the class. The pattern also provides a global point of access for the functionality contained in the sole instance of the class. A design pattern is a way for a software developer to handle situations using a known solution that has been proven to be effective in the past. Design patterns also make communicating ideas and concepts between programmers more efficient and understandable.

===Class Diagram===
[[Image:IC73826.gif|500px|center]]
===Sequence Diagram===
[[Image:CR2.gif|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects. [[#References|[1]]]

==Creating the instance==
===Early Instantiation===
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.
===Late Instantiation===
The instance of the class can be created after class loading. This can be done by only allocating the instance on the first access of the instance variable.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.
<pre>
private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}
</pre>
[[#References|[1]]]

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

<pre>
class genericFactory
include Singleton
end
</pre>
[[#References|[1]]]

==C++==
<pre>
// Declaration
class Singleton {
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}
</pre>
[[#References|[1]]]

=Benefits=

*This pattern allows the programmer to control the instances of a particular object, it ensures that all objects use the same instance of a class.

*The Singleton class has the ability to control the instantiation process since it implements the instantiation functionality.

=Drawbacks=

*Unit tests are much harder to write when using the Singleton pattern

*This pattern reduces the potential for parallelism within a program since the threads must be serialized.

*The overhead of checking whether there is an instance of a class that already exists every time an objects requests a reference. Although the overhead is minuscule, this could be a serious problem for systems which don't have the resources to waste.

*There may be some development confusion with implementing the singleton class (especially one defined in a class library) because developers may forget that they cannot use the "new" keyword to instantiate the object.

*The singleton design pattern doesn't address the issue of deleting the single object. Some languages implement memory management which means that the Singleton class can only be unallocated by itself since it holds a private reference to the instance of itself. In languages that don't provide memory management, then the single instance can be deleted but it will cause a dangling reference to that object.

=References=

[[#References|[1]]] Wikipedia. (2010, October) Wikipedia - Singleton_Pattern. [Online]. http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way

[[#References|[2]]] Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. (October 2004) Head First design patterns. [Print.]

[[#References|[3]]] C# Corner (2010, October) Creational Patterns - Singleton. [Online]. http://www.c-sharpcorner.com/UploadFile/susanabraham/CreationalPatterns06042005050058AM/CreationalPatterns.aspx

[[#References|[4]]] Source Making (2010, October) Singleton Design Pattern. [Online]. http://sourcemaking.com/design_patterns/singleton

[[#References|[5]]] JavaBeginner.com (2010, October) Java Singleton Design Pattern. [Online]. http://www.javabeginner.com/learn-java/java-singleton-design-pattern

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-14T02:09:55Z

Mlsurrat: /* Defintions */

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=
==Defintions==
<pre>
In the Singleton design pattern we create a single instance of a Singleton class. Any instantiation of that Singleton class references the same instance of the class. The pattern also provides a global point of access for the functionality contained in the sole instance of the class. A design pattern is a way for a software developer to handle situations using a known solution that has been proven to be effective in the past. Design patterns also make communicating ideas and concepts between programmers more efficient and understandable.
</pre>
===Class Diagram===
[[Image:IC73826.gif|500px|center]]
===Sequence Diagram===
[[Image:CR2.gif|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects. [[#References|[1]]]

==Creating the instance==
===Early Instantiation===
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.
===Late Instantiation===
The instance of the class can be created after class loading. This can be done by only allocating the instance on the first access of the instance variable.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.
<pre>
private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}
</pre>
[[#References|[1]]]

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

<pre>
class genericFactory
include Singleton
end
</pre>
[[#References|[1]]]

==C++==
<pre>
// Declaration
class Singleton {
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}
</pre>
[[#References|[1]]]

=Benefits=

*This pattern allows the programmer to control the instances of a particular object, it ensures that all objects use the same instance of a class.

*The Singleton class has the ability to control the instantiation process since it implements the instantiation functionality.

=Drawbacks=

*Unit tests are much harder to write when using the Singleton pattern

*This pattern reduces the potential for parallelism within a program since the threads must be serialized.

*The overhead of checking whether there is an instance of a class that already exists every time an objects requests a reference. Although the overhead is minuscule, this could be a serious problem for systems which don't have the resources to waste.

*There may be some development confusion with implementing the singleton class (especially one defined in a class library) because developers may forget that they cannot use the "new" keyword to instantiate the object.

*The singleton design pattern doesn't address the issue of deleting the single object. Some languages implement memory management which means that the Singleton class can only be unallocated by itself since it holds a private reference to the instance of itself. In languages that don't provide memory management, then the single instance can be deleted but it will cause a dangling reference to that object.

=References=

[[#References|[1]]] Wikipedia. (2010, October) Wikipedia - Singleton_Pattern. [Online]. http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way

[[#References|[2]]] Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. (October 2004) Head First design patterns. [Print.]

[[#References|[3]]] C# Corner (2010, October) Creational Patterns - Singleton. [Online]. http://www.c-sharpcorner.com/UploadFile/susanabraham/CreationalPatterns06042005050058AM/CreationalPatterns.aspx

[[#References|[4]]] Source Making (2010, October) Singleton Design Pattern. [Online]. http://sourcemaking.com/design_patterns/singleton

[[#References|[5]]] JavaBeginner.com (2010, October) Java Singleton Design Pattern. [Online]. http://www.javabeginner.com/learn-java/java-singleton-design-pattern

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-14T02:09:33Z

Mlsurrat:

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=
==Defintions==
In the Singleton design pattern we create a single instance of a Singleton class. Any instantiation of that Singleton class references the same instance of the class. The pattern also provides a global point of access for the functionality contained in the sole instance of the class. A design pattern is a way for a software developer to handle situations using a known solution that has been proven to be effective in the past. Design patterns also make communicating ideas and concepts between programmers more efficient and understandable.

===Class Diagram===
[[Image:IC73826.gif|500px|center]]
===Sequence Diagram===
[[Image:CR2.gif|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects. [[#References|[1]]]

==Creating the instance==
===Early Instantiation===
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.
===Late Instantiation===
The instance of the class can be created after class loading. This can be done by only allocating the instance on the first access of the instance variable.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.
<pre>
private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}
</pre>

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

<pre>
class genericFactory
include Singleton
end
</pre>

==C++==
<pre>
// Declaration
class Singleton {
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}
</pre>
[[#References|[1]]]

=Benefits=

*This pattern allows the programmer to control the instances of a particular object, it ensures that all objects use the same instance of a class.

*The Singleton class has the ability to control the instantiation process since it implements the instantiation functionality.

=Drawbacks=

*Unit tests are much harder to write when using the Singleton pattern

*This pattern reduces the potential for parallelism within a program since the threads must be serialized.

*The overhead of checking whether there is an instance of a class that already exists every time an objects requests a reference. Although the overhead is minuscule, this could be a serious problem for systems which don't have the resources to waste.

*There may be some development confusion with implementing the singleton class (especially one defined in a class library) because developers may forget that they cannot use the "new" keyword to instantiate the object.

*The singleton design pattern doesn't address the issue of deleting the single object. Some languages implement memory management which means that the Singleton class can only be unallocated by itself since it holds a private reference to the instance of itself. In languages that don't provide memory management, then the single instance can be deleted but it will cause a dangling reference to that object.

=References=

[[#References|[1]]] Wikipedia. (2010, October) Wikipedia - Singleton_Pattern. [Online]. http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way

[[#References|[2]]] Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. (October 2004) Head First design patterns. [Print.]

[[#References|[3]]] C# Corner (2010, October) Creational Patterns - Singleton. [Online]. http://www.c-sharpcorner.com/UploadFile/susanabraham/CreationalPatterns06042005050058AM/CreationalPatterns.aspx

[[#References|[4]]] Source Making (2010, October) Singleton Design Pattern. [Online]. http://sourcemaking.com/design_patterns/singleton

[[#References|[5]]] JavaBeginner.com (2010, October) Java Singleton Design Pattern. [Online]. http://www.javabeginner.com/learn-java/java-singleton-design-pattern

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-14T02:00:13Z

Mlsurrat:

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=
==Defintions==
In the Singleton design pattern we create a single instance of a Singleton class. Any instantiation of that Singleton class references the same instance of the class. The pattern also provides a global point of access for the functionality contained in the sole instance of the class. A design pattern is a way for a software developer to handle situations using a known solution that has been proven to be effective in the past. Design patterns also make communicating ideas and concepts between programmers more efficient and understandable.

===Class Diagram===
[[Image:IC73826.gif|500px|center]]
===Sequence Diagram===
[[Image:CR2.gif|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects. [[#References|[1]]]

==Creating the instance==
===Early Instantiation===
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.
===Late Instantiation===
The instance of the class can be created after class loading. This can be done by only allocating the instance on the first access of the instance variable.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.
<pre>
private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}
</pre>

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

<pre>
class genericFactory
include Singleton
end
</pre>

==C++==
<pre>
// Declaration
class Singleton {
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}
</pre>

=Drawbacks=

*Unit tests are much harder to write when using the Singleton pattern

*This pattern reduces the potential for parallelism within a program since the threads must be serialized.

*The overhead of checking whether there is an instance of a class that already exists every time an objects requests a reference. Although the overhead is minuscule, this could be a serious problem for systems which don't have the resources to waste.

*There may be some development confusion with implementing the singleton class (especially one defined in a class library) because developers may forget that they cannot use the "new" keyword to instantiate the object.

*The singleton design pattern doesn't address the issue of deleting the single object. Some languages implement memory management which means that the Singleton class can only be unallocated by itself since it holds a private reference to the instance of itself. In languages that don't provide memory management, then the single instance can be deleted but it will cause a dangling reference to that object.

=References=

[[#References|[1]]] Wikipedia. (2010, October) Wikipedia - Singleton_Pattern. [Online]. http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way

[[#References|[2]]] Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. (October 2004) Head First design patterns. [Print.]

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-14T01:59:09Z

Mlsurrat:

'''Singleton Pattern in Static and Dynamic languages'''

==Singleton pattern==

In the Singleton design pattern we create a single instance of a Singleton class. Any instantiation of that Singleton class references the same instance of the class. The pattern also provides a global point of access for the functionality contained in the sole instance of the class. A design pattern is a way for a software developer to handle situations using a known solution that has been proven to be effective in the past. Design patterns also make communicating ideas and concepts between programmers more efficient and understandable.

===Class Diagram===
[[Image:IC73826.gif|500px|center]]
===Sequence Diagram===
[[Image:CR2.gif|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects. [[#References|[1]]]

==Creating the instance==
===Early Instantiation===
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.
===Late Instantiation===
The instance of the class can be created after class loading. This can be done by only allocating the instance on the first access of the instance variable.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.
<pre>
private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}
</pre>

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

<pre>
class genericFactory
include Singleton
end
</pre>

==C++==
<pre>
// Declaration
class Singleton {
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}
</pre>

=Drawbacks=

*Unit tests are much harder to write when using the Singleton pattern

*This pattern reduces the potential for parallelism within a program since the threads must be serialized.

*The overhead of checking whether there is an instance of a class that already exists every time an objects requests a reference. Although the overhead is minuscule, this could be a serious problem for systems which don't have the resources to waste.

*There may be some development confusion with implementing the singleton class (especially one defined in a class library) because developers may forget that they cannot use the "new" keyword to instantiate the object.

*The singleton design pattern doesn't address the issue of deleting the single object. Some languages implement memory management which means that the Singleton class can only be unallocated by itself since it holds a private reference to the instance of itself. In languages that don't provide memory management, then the single instance can be deleted but it will cause a dangling reference to that object.

=References=

[[#References|[1]]] Wikipedia. (2010, October) Wikipedia - Singleton_Pattern. [Online]. http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way

[[#References|[2]]] Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. (October 2004) Head First design patterns. [Print.]

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-14T01:45:53Z

Mlsurrat: /* Singleton pattern */

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=

In the Singleton design pattern we create a single instance of a Singleton class. Any instantiation of that Singleton class references the same instance of the class. The pattern also provides a global point of access for the functionality contained in the sole instance of the class.

===Class Diagram===
[[Image:IC73826.gif|500px|center]]
===Sequence Diagram===
[[Image:CR2.gif|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects. [[#References|[1]]]

==Creating the instance==
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.
<pre>
private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}
</pre>

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

<pre>
class genericFactory
include Singleton
end
</pre>

==C++==
<pre>
// Declaration
class Singleton {
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}
</pre>

=Drawbacks=

*Unit tests are much harder to write when using the Singleton pattern

*This pattern reduces the potential for parallelism within a program since the threads must be serialized.

*The overhead of checking whether there is an instance of a class that already exists every time an objects requests a reference. Although the overhead is minuscule, this could be a serious problem for systems which don't have the resources to waste.

*There may be some development confusion with implementing the singleton class (especially one defined in a class library) because developers may forget that they cannot use the "new" keyword to instantiate the object.

*The singleton design pattern doesn't address the issue of deleting the single object. Some languages implement memory management which means that the Singleton class can only be unallocated by itself since it holds a private reference to the instance of itself. In languages that don't provide memory management, then the single instance can be deleted but it will cause a dangling reference to that object.

=References=

[[#References|[1]]] Wikipedia. (2010, October) Wikipedia - Singleton_Pattern. [Online]. http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way

[[#References|[2]]] Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. (October 2004) Head First design patterns. [Print.]

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-14T01:45:32Z

Mlsurrat:

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=
In the Singleton design pattern we create a single instance of a Singleton class. Any instantiation of that Singleton class references the same instance of the class. The pattern also provides a global point of access for the functionality contained in the sole instance of the class.

===Class Diagram===
[[Image:IC73826.gif|500px|center]]
===Sequence Diagram===
[[Image:CR2.gif|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects. [[#References|[1]]]

==Creating the instance==
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.
<pre>
private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}
</pre>

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

<pre>
class genericFactory
include Singleton
end
</pre>

==C++==
<pre>
// Declaration
class Singleton {
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}
</pre>

=Drawbacks=

*Unit tests are much harder to write when using the Singleton pattern

*This pattern reduces the potential for parallelism within a program since the threads must be serialized.

*The overhead of checking whether there is an instance of a class that already exists every time an objects requests a reference. Although the overhead is minuscule, this could be a serious problem for systems which don't have the resources to waste.

*There may be some development confusion with implementing the singleton class (especially one defined in a class library) because developers may forget that they cannot use the "new" keyword to instantiate the object.

*The singleton design pattern doesn't address the issue of deleting the single object. Some languages implement memory management which means that the Singleton class can only be unallocated by itself since it holds a private reference to the instance of itself. In languages that don't provide memory management, then the single instance can be deleted but it will cause a dangling reference to that object.

=References=

[[#References|[1]]] Wikipedia. (2010, October) Wikipedia - Singleton_Pattern. [Online]. http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way

[[#References|[2]]] Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. (October 2004) Head First design patterns. [Print.]

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-14T01:17:46Z

Mlsurrat:

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=
A singleton pattern is a design pattern that restricts the amount of instantiations of a class to one object. This pattern is implemented when exactly one object is needed to coordinate actions across the entire system. The restriction of only having one object can sometimes make the system more efficient and allow the programmer to exercise more control over certain actions in the system. A singleton must satisfy some global access principles, which say all of the classes must be able to access the functionality contained in the singleton class/es.

===Class Diagram===
[[Image:IC73826.gif|500px|center]]
===Sequence Diagram===
[[Image:CR2.gif|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects.

==Creating the instance==
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.

private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

include Singleton

==C++==

// Declaration
class Singleton {
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}

=Drawbacks=

1) Unit tests are much harder to write when using the Singleton pattern

2) This pattern reduces the potential for parallelism within a program since the threads must be serialized.

3) The overhead of checking whether there is an instance of a class that already exists every time an objects requests a reference. Although the overhead is minuscule, this could be a serious problem for systems which don't have the resources to waste.

4) There may be some development confusion with implementing the singleton class (especially one defined in a class library) because developers may forget that they cannot use the "new" keyword to instantiate the object.

5) The singleton design pattern doesn't address the issue of deleting the single object. Some languages implement memory management which means that the Singleton class can only be unallocated by itself since it holds a private reference to the instance of itself. In languages that don't provide memory management, then the single instance can be deleted but it will cause a dangling reference to that object.

=References=
[Wikipedia Article[http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way].
[[http://oreilly.com/catalog/9780596007126]Design Textbook]

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-13T22:02:30Z

Mlsurrat:

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=
A singleton pattern is a design pattern that restricts the amount of instantiations of a class to one object. This pattern is implemented when exactly one object is needed to coordinate actions across the entire system. The restriction of only having one object can sometimes make the system more efficient and allow the programmer to exercise more control over certain actions in the system. A singleton must satisfy some global access principles, which say all of the classes must be able to access the functionality contained in the singleton class/es.

===Class Diagram===
[[Image:IC73826.gif|500px|center]]
===Sequence Diagram===
[[Image:CR2.gif|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects.

==Creating the instance==
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.

private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

include Singleton

==C++==

// Declaration
class Singleton {
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}

=Drawbacks=

1) Unit tests are much harder to write when using the Singleton pattern

2) This pattern reduces the potential for parallelism within a program since the threads must be serialized.

3) The overhead of checking whether there is an instance of a class that already exists every time an objects requests a reference. Although the overhead is minuscule, this could be a serious problem for systems which don't have the resources to waste.

4) There may be some development confusion with implementing the singleton class (especially one defined in a class library) because developers may forget that they cannot use the "new" keyword to instantiate the object.

5) The singleton design pattern doesn't address the issue of deleting the single object. Some languages implement memory management which means that the Singleton class can only be unallocated by itself since it holds a private reference to the instance of itself. In languages that don't provide memory management, then the single instance can be deleted but it will cause a dangling reference to that object.

=References=
[[http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way]Wikipedia Article].
[[http://oreilly.com/catalog/9780596007126]Design Textbook]

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-13T21:57:18Z

Mlsurrat:

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=
A singleton pattern is a design pattern that restricts the amount of instantiations of a class to one object. This pattern is implemented when exactly one object is needed to coordinate actions across the entire system. The restriction of only having one object can sometimes make the system more efficient and allow the programmer to exercise more control over certain actions in the system. A singleton must satisfy some global access principles, which say all of the classes must be able to access the functionality contained in the singleton class/es.

===Class Diagram===
[[Image:IC73826.gif|500px|center]]
===Sequence Diagram===
[[Image:CR2.gif|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects.

==Creating the instance==
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.

private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

include Singleton

==C++==

// Declaration
class Singleton {
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}

=Drawbacks=

1) Unit tests are much harder to write when using the Singleton pattern

2) This pattern reduces the potential for parallelism within a program since the threads must be serialized.

3) The overhead of checking whether there is an instance of a class that already exists every time an objects requests a reference. Although the overhead is minuscule, this could be a serious problem for systems which don't have the resources to waste.

=References=
[[http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way]Wikipedia Article].
[[http://oreilly.com/catalog/9780596007126]Design Textbook]

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-13T21:27:10Z

Mlsurrat:

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=
A singleton pattern is a design pattern that restricts the amount of instantiations of a class to one object. This pattern is implemented when exactly one object is needed to coordinate actions across the entire system. The restriction of only having one object can sometimes make the system more efficient and allow the programmer to exercise more control over certain actions in the system. A singleton must satisfy some global access principles, which say all of the classes must be able to access the functionality contained in the singleton class/es.

===Class Diagram===
[[Image:IC73826.gif|500px|center]]
===Sequence Diagram===
[[Image:CR2.gif|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects.

==Creating the instance==
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.

private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

include Singleton

==C++==

// Declaration
class Singleton {
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}

=Drawbacks=

1) Unit tests are much harder to write when using the Singleton pattern

2) This pattern reduces the potential for parallelism within a program since the threads must be serialized.

=References=
[[http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way]Wikipedia Article].
[[http://oreilly.com/catalog/9780596007126]Design Textbook]

File:IC73826.gif

2010-10-13T21:26:49Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-13T21:26:03Z

Mlsurrat:

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=
A singleton pattern is a design pattern that restricts the amount of instantiations of a class to one object. This pattern is implemented when exactly one object is needed to coordinate actions across the entire system. The restriction of only having one object can sometimes make the system more efficient and allow the programmer to exercise more control over certain actions in the system. A singleton must satisfy some global access principles, which say all of the classes must be able to access the functionality contained in the singleton class/es.

===Class Diagram===
[[Image:500px-Singleton_UML_class_diagram.svg.png|500px|center]]
===Sequence Diagram===
[[Image:CR2.gif|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects.

==Creating the instance==
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.

private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

include Singleton

==C++==

// Declaration
class Singleton {
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}

=Drawbacks=

1) Unit tests are much harder to write when using the Singleton pattern

2) This pattern reduces the potential for parallelism within a program since the threads must be serialized.

=References=
[[http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way]Wikipedia Article].
[[http://oreilly.com/catalog/9780596007126]Design Textbook]

File:CR2.gif

2010-10-13T21:25:48Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-13T21:15:52Z

Mlsurrat:

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=
A singleton pattern is a design pattern that restricts the amount of instantiations of a class to one object. This pattern is implemented when exactly one object is needed to coordinate actions across the entire system. The restriction of only having one object can sometimes make the system more efficient and allow the programmer to exercise more control over certain actions in the system. A singleton must satisfy some global access principles, which say all of the classes must be able to access the functionality contained in the singleton class/es.
[[Image:500px-Singleton_UML_class_diagram.svg.png|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects.

==Creating the instance==
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.

private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

include Singleton

==C++==

// Declaration
class Singleton {
public:
static Singleton* Instance();
function protected:
Singleton();
function private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

function Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}

=Drawbacks=

1) Unit tests are much harder to write when using the Singleton pattern

2) This pattern reduces the potential for parallelism within a program since the threads must be serialized.

=References=
[[http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way]Wikipedia Article].
[[http://oreilly.com/catalog/9780596007126]Design Textbook]

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-13T21:15:14Z

Mlsurrat:

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=
A singleton pattern is a design pattern that restricts the amount of instantiations of a class to one object. This pattern is implemented when exactly one object is needed to coordinate actions across the entire system. The restriction of only having one object can sometimes make the system more efficient and allow the programmer to exercise more control over certain actions in the system. A singleton must satisfy some global access principles, which say all of the classes must be able to access the functionality contained in the singleton class/es.
[[Image:500px-Singleton_UML_class_diagram.svg.png|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects.

==Creating the instance==
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.

private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

include Singleton

==C++==

// Declaration
class Singleton {
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
}

// Implementation
Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance() {
if (_instance == 0) {
_instance = new Singleton;
}
return _instance;
}

=Drawbacks=

1) Unit tests are much harder to write when using the Singleton pattern

2) This pattern reduces the potential for parallelism within a program since the threads must be serialized.

=References=
[[http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way]Wikipedia Article].
[[http://oreilly.com/catalog/9780596007126]Design Textbook]

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-13T17:31:45Z

Mlsurrat:

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=
A singleton pattern is a design pattern that restricts the amount of instantiations of a class to one object. This pattern is implemented when exactly one object is needed to coordinate actions across the entire system. The restriction of only having one object can sometimes make the system more efficient and allow the programmer to exercise more control over certain actions in the system. A singleton must satisfy some global access principles, which say all of the classes must be able to access the functionality contained in the singleton class/es.
[[Image:500px-Singleton_UML_class_diagram.svg.png|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects.

==Creating the instance==
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.

private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

include Singleton

=Drawbacks=

1) Unit tests are much harder to write when using the Singleton pattern

2) This pattern reduces the potential for parallelism within a program since the threads must be serialized.

=References=
[[http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way]Wikipedia Article].
[[http://oreilly.com/catalog/9780596007126]Design Textbook]

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-13T17:20:57Z

Mlsurrat:

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=
A singleton pattern is a design pattern that restricts the amount of instantiations of a class to one object. This pattern is implemented when exactly one object is needed to coordinate actions across the entire system. The restriction of only having one object can sometimes make the system more efficient and allow the programmer to exercise more control over certain actions in the system. A singleton must satisfy some global access principles, which say all of the classes must be able to access the functionality contained in the singleton class/es.
[[Image:500px-Singleton_UML_class_diagram.svg.png|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects.

==Creating the instance==
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.

private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

include Singleton

=Drawbacks=

1) Unit tests are much harder to write when using the Singleton pattern

2) This pattern reduces the potential for parallelism within a program since the threads must be serialized.

=References=
[[http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way]Wikipedia Article]
[[http://oreilly.com/catalog/9780596007126]Design Textbook]

CSC/ECE 517 Fall 2010/ch1 S10 ms

2010-10-13T17:07:44Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-06T05:34:29Z

Mlsurrat:

'''Singleton Pattern in Static and Dynamic languages'''

=Singleton pattern=
A singleton pattern is a design pattern that restricts the amount of instantiations of a class to one object. This pattern is implemented when exactly one object is needed to coordinate actions across the entire system. The restriction of only having one object can sometimes make the system more efficient and allow the programmer to exercise more control over certain actions in the system. A singleton must satisfy some global access principles, which say all of the classes must be able to access the functionality contained in the singleton class/es.
[[Image:500px-Singleton_UML_class_diagram.svg.png|500px|center]]

=Implementation=
When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects.

==Creating the instance==
The instance can be created with a static constructor in static languages. (See the java example below) This means that the single instance is created on program start up and all new methods are private and never used except by the singleton class itself.

In static languages, this is accomplished by setting the constructors to private and controlling creation of instance of the object from within the object itself.

In dynamic languages, this is done by changing the access level of the constructor to prevent use outside the class just as in the static patterns.

==Accessing the instance==

In static languages, such as Java, the Singleton class will have a method which returns the instance of the Singleton class so that the other classes can use the functionality encapsulated in the Singleton class.

In dynamic languages, such as Ruby, if a class needs to access the functionality within the Singleton class then it simply needs to access the instance variable @instance and all the functionality therein.

=Examples=
==Java==

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized. Java also utilizes a constructor to initialize the Singleton class.

private static final Singleton INSTANCE = new Singleton();

// Private constructor prevents instantiation from other classes
private Singleton() {
}

public static Singleton getInstance() {
return INSTANCE;
}

==Ruby==

Ruby implements the Singleton pattern by privatizing the "new" method and creates an instance variable called @instance. This implementation guarantees that the class will not be able create more than one instantiation of itself and that the system will have the global access privileges since the @instance variable has a global scope.

include Singleton

=Drawbacks=

1) Unit tests are much harder to write when using the Singleton pattern

2) This pattern reduces the potential for parallelism within a program since the threads must be serialized.

=References=
[[http://en.wikipedia.org/wiki/Singleton_pattern#Traditional_simple_way]Wikipedia Article]
http://oreilly.com/catalog/9780596007126

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-06T05:28:49Z

Mlsurrat: /* References */

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-06T05:28:18Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-06T05:26:32Z

Mlsurrat: /* Singleton pattern */

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-06T05:25:49Z

Mlsurrat:

File:500px-Singleton UML class diagram.svg.png

2010-10-06T05:24:56Z

Mlsurrat:

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-06T05:23:00Z

Mlsurrat: /* Singleton pattern */

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-06T05:22:21Z

Mlsurrat: /* Java */

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-06T05:21:15Z

Mlsurrat: /* Accessing the instance */

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-06T05:14:40Z

Mlsurrat: /* Accessing the instance */

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-06T05:09:09Z

Mlsurrat: /* Ruby */

CSC/ECE 517 Fall 2010/ch3 3f lj

2010-10-06T05:08:32Z

Mlsurrat: /* Ruby */