Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2014/final design doc M1451 hsss

2014-11-12T02:55:49Z

Hmarfat: /* Appendix */

This wiki page contains details on the planned course of actions for the project on [https://github.com/servo/servo/wiki/WebSocket-student-project Implement WebSocket API] for the Mozilla research project [http://github.com/servo/servo/wiki/Design Servo].

== Introduction ==
About Servo<ref> https://www.mozilla.org/en-US/research/projects/</ref>
 
Servo is an project to build a Web browser engine for a new generation of hardware. With Servo, we are rethinking the browser at every level of the technology stack — from input parsing to page layout to graphics rendering — to optimize for power efficiency and maximum parallelism.
 
About Rust<ref>http://en.wikipedia.org/wiki/Rust_%28programming_language%29</ref>
 
The goal of Rust is to be a good language for the creation of large client and server programs that run over the Internet. This has led to a feature set with an emphasis on safety, control of memory layout and concurrency. Performance of safe code is expected to be slower than C++ if performance is the only consideration, but to be comparable to C++ code that manually takes precautions comparable to what the Rust language mandates.
 
Purpose
 
This project is about implementing a protocol to define rules regarding the nature of data being sent/receive between the web page and the server built on a Mozilla Framework. We started by creating a WebSocket interface and its corresponding Rust implementation. The constructor of this interface returns a WebSocket object which will help us in establishing a basic HTTP connection to the server. Thereafter we plan to implement methods like close, open on the API along with the onopen and onclose events.

This WebSocket interface runs on a [https://github.com/servo/servo Servo] engine. It is basically a prototype web browser engine written in the [https://github.com/rust-lang/rust Rust] language. It is currently developed on 64bit OS X and 64bit Linux. Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a
solid, embedded engine.

== Architecture of system <ref>https://github.com/servo/servo/wiki/Design#task-supervision-diagram</ref> ==

=== Task Supervision Diagram ===

[[File:TaskSupervision.png]]

=== Task Communication Diagram ===

[[File:TaskCommunication.png]]

The above diagrams gives us an overview of the Servo's architecture.

*Each box represents a Rust task.

*Primary tasks are the ones which are represented by blue boxes.

*Gray boxes are for auxiliary tasks.

*White boxes are for worker tasks. Each such box represents several tasks, the precise number of which are decided by the workload.

*Supervisor relationships are shown by dashed lines.

*Communication channels are shown by solid lines.

== Requirement analysis<ref>https://github.com/servo/servo/wiki/WebSocket-student-project</ref> ==

1. The initial step required downloading and building the Rust compiler. To install Rust on the machine, clone the Rust source code from Mozilla's repository on GitHub.
 

2. Then we had to build the rust compiler.
 

3. To build the servo, we cloned the source code into the local repository.
 

4. Then we created a WebSocket.webidl file in the /servo/components/script/dom/webidls/ directory. This file was added in order to create a new interface for the web socket.This interface is inherited from the EventTarget interface in servo.
 

5. We added several attributes and methods to the WebSocket.webidl file which we plan to execute during the course of the project<ref>https://html.spec.whatwg.org/multipage/comms.html</ref>.
 

6. We created a corresponding websocket.rs file in the /servo/components/script/dom/ directory. In this file we have currently created a constructor that takes a url as an argument. We have a stub function to return the url that is used for initializing the web socket object through the constructor.
 

7. We added The WebSocketTypeId to the struct in the eventtarget.rs file.
 

8. We added the websocket module that we created to the lib.rs file.
 

9. After making all the changes we build are changes into servo.
 

10. This was Part One of our project, which was a part of our OSS project.
 

11. Part Two is our final project and is an extension of our OSS project.
 

12. Now we will create a constructor which will return an WebSocket object and initiate a basic connection with the server. There are couple of sub parts we will need here:
*A ws scheme protocol handler (just as we have an http scheme protocol handler) that will implement the WS-specific parts of the connection process.

*The ws protocol load method should transparently delegate the initial HTTP connection to http_loader::factory(); this way we do not need to duplicate the HTTP protocol code.

*Using the same technique as the [http://en.wikipedia.org/wiki/MIME MIME] sniffing project, the WS load method should intercept the response from the HTTP load. This will allow us to look at the HTTP response and verify the presence of the required Upgrade header as described in the spec before sending the connection results to the WebSocket implementation

13. In order to allow writing more data to the existing socket connection, we plan to make the stream member in the BufferedResponse in rust-http public.
 

14. We have to implement closing of connection along with on open and inclose events.
 

15. Furthermore, we have to implement sending simple short strings that fit within a single frame, receiving simple data and sending fragmented payloads across multiple frames.

== Data and component design ==
Flowchart:
 
[[File:Workflow.png]]

== Design patterns ==

=== Singleton Pattern ===
We are using [http://en.wikipedia.org/wiki/Singleton_pattern "Singleton Pattern"] because it will confine the instantiation of class 'WebSocket' to only one object. This ensures that the instance can be accessed from everywhere and hence provide a global point of access.

=== Adapter Pattern ===
We are using [http://en.wikipedia.org/wiki/Adapter_pattern "Adapter Pattern"] to convert the interface of class 'WebSocket' into another interface that the caller expects. "Adapter pattern" allows other classes with incompatible interfaces to work together with class 'WebSocket', which is solely responsible to enable Web applications to maintain bidirectional communications with server-side processes.

== UML diagram: UseCase Diagram ==
[[File:UseCaseDiagram_websocket.png]]
 
Use Cases:
 
*Create a web socket object:
This object allows a basic connection to the server.
 
*Call the onopen function:
Connection along with on open event.
 
*Call the onclose function:
Connection along with on close event.
 
*Call the onmessage function:
Receiving of simple data and the on message event.
 
*Call the send function:
Sends fragmented data.

==Proposed Test Cases==

*Validating the url used to create a websocket object.

*Checking if the connection with the remote server is established.

*Check with session variables are reset on creating a new connection.

*Check if the data if the messages are delivered to the remote host.

*When the user agent validates the server's response during the "establish a WebSocket connection" algorithm, if the status code received from the server is not 101 (e.g. it is a redirect), it must fail the WebSocket connection.

==Appendix==

*Steps used for [https://github.com/rust-lang/rust/wiki/Note-getting-started-developing-Rust Installing Rust].

*Steps used for [https://github.com/servo/servo Building Servo].

== References ==
<references/>

CSC/ECE 517 Fall 2014/final design doc M1451 hsss

2014-11-12T02:54:17Z

Hmarfat:

This wiki page contains details on the planned course of actions for the project on [https://github.com/servo/servo/wiki/WebSocket-student-project Implement WebSocket API] for the Mozilla research project [http://github.com/servo/servo/wiki/Design Servo].

== Introduction ==
About Servo<ref> https://www.mozilla.org/en-US/research/projects/</ref>
 
Servo is an project to build a Web browser engine for a new generation of hardware. With Servo, we are rethinking the browser at every level of the technology stack — from input parsing to page layout to graphics rendering — to optimize for power efficiency and maximum parallelism.
 
About Rust<ref>http://en.wikipedia.org/wiki/Rust_%28programming_language%29</ref>
 
The goal of Rust is to be a good language for the creation of large client and server programs that run over the Internet. This has led to a feature set with an emphasis on safety, control of memory layout and concurrency. Performance of safe code is expected to be slower than C++ if performance is the only consideration, but to be comparable to C++ code that manually takes precautions comparable to what the Rust language mandates.
 
Purpose
 
This project is about implementing a protocol to define rules regarding the nature of data being sent/receive between the web page and the server built on a Mozilla Framework. We started by creating a WebSocket interface and its corresponding Rust implementation. The constructor of this interface returns a WebSocket object which will help us in establishing a basic HTTP connection to the server. Thereafter we plan to implement methods like close, open on the API along with the onopen and onclose events.

This WebSocket interface runs on a [https://github.com/servo/servo Servo] engine. It is basically a prototype web browser engine written in the [https://github.com/rust-lang/rust Rust] language. It is currently developed on 64bit OS X and 64bit Linux. Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a
solid, embedded engine.

== Architecture of system <ref>https://github.com/servo/servo/wiki/Design#task-supervision-diagram</ref> ==

=== Task Supervision Diagram ===

[[File:TaskSupervision.png]]

=== Task Communication Diagram ===

[[File:TaskCommunication.png]]

The above diagrams gives us an overview of the Servo's architecture.

*Each box represents a Rust task.

*Primary tasks are the ones which are represented by blue boxes.

*Gray boxes are for auxiliary tasks.

*White boxes are for worker tasks. Each such box represents several tasks, the precise number of which are decided by the workload.

*Supervisor relationships are shown by dashed lines.

*Communication channels are shown by solid lines.

== Requirement analysis<ref>https://github.com/servo/servo/wiki/WebSocket-student-project</ref> ==

1. The initial step required downloading and building the Rust compiler. To install Rust on the machine, clone the Rust source code from Mozilla's repository on GitHub.
 

2. Then we had to build the rust compiler.
 

3. To build the servo, we cloned the source code into the local repository.
 

4. Then we created a WebSocket.webidl file in the /servo/components/script/dom/webidls/ directory. This file was added in order to create a new interface for the web socket.This interface is inherited from the EventTarget interface in servo.
 

5. We added several attributes and methods to the WebSocket.webidl file which we plan to execute during the course of the project<ref>https://html.spec.whatwg.org/multipage/comms.html</ref>.
 

6. We created a corresponding websocket.rs file in the /servo/components/script/dom/ directory. In this file we have currently created a constructor that takes a url as an argument. We have a stub function to return the url that is used for initializing the web socket object through the constructor.
 

7. We added The WebSocketTypeId to the struct in the eventtarget.rs file.
 

8. We added the websocket module that we created to the lib.rs file.
 

9. After making all the changes we build are changes into servo.
 

10. This was Part One of our project, which was a part of our OSS project.
 

11. Part Two is our final project and is an extension of our OSS project.
 

12. Now we will create a constructor which will return an WebSocket object and initiate a basic connection with the server. There are couple of sub parts we will need here:
*A ws scheme protocol handler (just as we have an http scheme protocol handler) that will implement the WS-specific parts of the connection process.

*The ws protocol load method should transparently delegate the initial HTTP connection to http_loader::factory(); this way we do not need to duplicate the HTTP protocol code.

*Using the same technique as the [http://en.wikipedia.org/wiki/MIME MIME] sniffing project, the WS load method should intercept the response from the HTTP load. This will allow us to look at the HTTP response and verify the presence of the required Upgrade header as described in the spec before sending the connection results to the WebSocket implementation

13. In order to allow writing more data to the existing socket connection, we plan to make the stream member in the BufferedResponse in rust-http public.
 

14. We have to implement closing of connection along with on open and inclose events.
 

15. Furthermore, we have to implement sending simple short strings that fit within a single frame, receiving simple data and sending fragmented payloads across multiple frames.

== Data and component design ==
Flowchart:
 
[[File:Workflow.png]]

== Design patterns ==

=== Singleton Pattern ===
We are using [http://en.wikipedia.org/wiki/Singleton_pattern "Singleton Pattern"] because it will confine the instantiation of class 'WebSocket' to only one object. This ensures that the instance can be accessed from everywhere and hence provide a global point of access.

=== Adapter Pattern ===
We are using [http://en.wikipedia.org/wiki/Adapter_pattern "Adapter Pattern"] to convert the interface of class 'WebSocket' into another interface that the caller expects. "Adapter pattern" allows other classes with incompatible interfaces to work together with class 'WebSocket', which is solely responsible to enable Web applications to maintain bidirectional communications with server-side processes.

== UML diagram: UseCase Diagram ==
[[File:UseCaseDiagram_websocket.png]]
 
Use Cases:
 
*Create a web socket object:
This object allows a basic connection to the server.
 
*Call the onopen function:
Connection along with on open event.
 
*Call the onclose function:
Connection along with on close event.
 
*Call the onmessage function:
Receiving of simple data and the on message event.
 
*Call the send function:
Sends fragmented data.

==Proposed Test Cases==

*Validating the url used to create a websocket object.

*Checking if the connection with the remote server is established.

*Check with session variables are reset on creating a new connection.

*Check if the data if the messages are delivered to the remote host.

==Appendix==

-Steps used for [https://github.com/rust-lang/rust/wiki/Note-getting-started-developing-Rust Installing Rust].

-Steps used for [https://github.com/servo/servo Building Servo].

== References ==
<references/>

CSC/ECE 517 Fall 2014/final design doc M1451 hsss

2014-11-12T02:51:45Z

Hmarfat:

File:Websocket.jpg

2014-11-11T23:57:08Z

Hmarfat:

File:Diagram websocket.jpg

2014-11-11T23:54:14Z

Hmarfat:

[[File:Diagram_websocket.jpg]]

File:Diagram websocket.jpg

2014-11-11T23:53:44Z

Hmarfat:

File:WorkflowChart.png

2014-11-11T23:50:39Z

Hmarfat:

File:Workflow.png

2014-11-11T23:49:55Z

Hmarfat:

[[File:Workflow.png]]

File:Workflow.png

2014-11-11T23:49:18Z

Hmarfat:

File:Screen Shot 2014-11-11 at 6.44.22 PM.png

2014-11-11T23:47:12Z

Hmarfat: uploaded a new version of "File:Screen Shot 2014-11-11 at 6.44.22 PM.png"

File:Screen Shot 2014-11-11 at 6.44.22 PM.png

2014-11-11T23:46:10Z

Hmarfat:

CSC/ECE 517 Fall 2014/OSS M1451 ahs

2014-10-30T01:04:59Z

Hmarfat: /* Design Pattern */

[https://docs.google.com/a/ncsu.edu/document/d/18VECpUuVmEaC4Xew4EsIAmOsRKdIeXaTA42tLlNwIho/edit Project Topic Page]
== Implement the WebSocket API ==
This wiki page contains details on the work done for the initial step of the task of [https://github.com/servo/servo/wiki/WebSocket-student-project Implement WebSocket API] for the Mozilla research project [http://github.com/servo/servo/wiki/Design Servo].

= Introduction =

== Rust <ref>http://en.wikipedia.org/wiki/Rust_(programming_language)</ref>==
Rust is a curly-brace, block-structured expression language.

*It visually resembles the C language family, but differs significantly in syntactic and semantic details.

*Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

*It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and
metaprogramming, in both static and dynamic styles.

*Example:
<pre>
fn main() {
println!("hello, world");
}
</pre>

== Servo <ref>http://en.wikipedia.org/wiki/Servo_(layout_engine)</ref> ==
Servo is an experimental web browser layout engine being developed by Mozilla.

*The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are
handled by fine-grained, isolated tasks.

*The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

*Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a
solid, embedded engine. Although Servo is a research project, it is designed to be "productisable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

== Task Architecture Diagrams<ref>https://github.com/servo/servo/wiki/Design#task-supervision-diagram</ref> ==

=== Task Supervision Diagram ===

[[File:TaskSupervision.png]]

=== Task Communication Diagram ===

[[File:TaskCommunication.png]]

=Implementation Steps=
We carried out the implementation for this project on a Mac machine. The steps we followed for the implementation are as follows:

== Compiling Rust ==
1. The initial step to build Servo required downloading and building the Rust compiler. To install Rust on the machine, clone the Rust source code from Mozilla's repository on GitHub using the following command:
<pre>
git clone git://github.com/mozilla/rust.git
cd rust
./configure
</pre>
2. Use the following commands to build the Rust compiler:
<pre>
make
make check
make install
</pre>

This will build and test the compiler, standard libraries, and supporting tools.

== Build Servo ==
1. Fork the servo repository and clone the source code into the local repository using the command:
<pre>
git clone https://github.com/servo/servo
</pre>
2. Build servo using the following commands:
<pre>
cd servo
./mach build
./mach run tests/html/about-mozilla.html
</pre>

== Part One Of the Project ==

-Created a WebSocket.webidl file in the /servo/components/script/dom/webidls/ directory. This file was added in order to create a new interface for the web socket.This interface is inherited from the EventTarget interface in servo.

-We added several attributes and methods to the WebSocket.webidl file which we plan to execute during the course of the project <ref>https://html.spec.whatwg.org/multipage/comms.html</ref>.

-We created a corresponding websocket.rs file in the /servo/components/script/dom/ directory. In this file we have currently created a constructor that takes a url as an argument. We have a stub function to return the url that is used for initializing the web socket object through the constructor.

-We added The WebSocketTypeId to the struct in the eventtarget.rs file.

-We added the websocket module that we created to the lib.rs file.

-After making all the changes we build are changes into servo.

-Created a [https://github.com/servo/servo/pull/3813 pull request].

= Future Goals for the Project =

-Create a basic connection to the server using the websocket connection protocol as specified in the [http://tools.ietf.org/html/rfc6455#section-4.1 protocol spec].

-In order to allow writing more data to the existing socket connection, we plan to make the stream member in the BufferedResponse in rust-http public.

-Implement closing of connection along with on open and inclose events.

-Implement sending of short simple strings which fit within a single frame.

-Implement receiving of simple data and the on message event.

-Implement sending of fragmented data.

= Design Pattern =

We plan to implement the Factory<ref>http://en.wikipedia.org/wiki/Factory_(object-oriented_programming)</ref> design Pattern since out implementation of the WebSocket interface is a child of the EventTarget interface in Servo.

= Appendix =

-Steps for [https://github.com/rust-lang/rust/wiki/Note-getting-started-developing-Rust Installing Rust] in detail.

-Steps for [https://github.com/servo/servo Building Servo] in detail.

=References=
<references/>

CSC/ECE 517 Fall 2014/OSS M1451 ahs

2014-10-30T01:02:46Z

Hmarfat:

[https://docs.google.com/a/ncsu.edu/document/d/18VECpUuVmEaC4Xew4EsIAmOsRKdIeXaTA42tLlNwIho/edit Project Topic Page]
== Implement the WebSocket API ==
This wiki page contains details on the work done for the initial step of the task of [https://github.com/servo/servo/wiki/WebSocket-student-project Implement WebSocket API] for the Mozilla research project [http://github.com/servo/servo/wiki/Design Servo].

= Introduction =

== Rust <ref>http://en.wikipedia.org/wiki/Rust_(programming_language)</ref>==
Rust is a curly-brace, block-structured expression language.

*It visually resembles the C language family, but differs significantly in syntactic and semantic details.

*Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

*It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and
metaprogramming, in both static and dynamic styles.

*Example:
<pre>
fn main() {
println!("hello, world");
}
</pre>

== Servo <ref>http://en.wikipedia.org/wiki/Servo_(layout_engine)</ref> ==
Servo is an experimental web browser layout engine being developed by Mozilla.

*The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are
handled by fine-grained, isolated tasks.

*The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

*Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a
solid, embedded engine. Although Servo is a research project, it is designed to be "productisable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

== Task Architecture Diagrams<ref>https://github.com/servo/servo/wiki/Design#task-supervision-diagram</ref> ==

=== Task Supervision Diagram ===

[[File:TaskSupervision.png]]

=== Task Communication Diagram ===

[[File:TaskCommunication.png]]

=Implementation Steps=
We carried out the implementation for this project on a Mac machine. The steps we followed for the implementation are as follows:

== Compiling Rust ==
1. The initial step to build Servo required downloading and building the Rust compiler. To install Rust on the machine, clone the Rust source code from Mozilla's repository on GitHub using the following command:
<pre>
git clone git://github.com/mozilla/rust.git
cd rust
./configure
</pre>
2. Use the following commands to build the Rust compiler:
<pre>
make
make check
make install
</pre>

This will build and test the compiler, standard libraries, and supporting tools.

== Build Servo ==
1. Fork the servo repository and clone the source code into the local repository using the command:
<pre>
git clone https://github.com/servo/servo
</pre>
2. Build servo using the following commands:
<pre>
cd servo
./mach build
./mach run tests/html/about-mozilla.html
</pre>

== Part One Of the Project ==

-Created a WebSocket.webidl file in the /servo/components/script/dom/webidls/ directory. This file was added in order to create a new interface for the web socket.This interface is inherited from the EventTarget interface in servo.

-We added several attributes and methods to the WebSocket.webidl file which we plan to execute during the course of the project <ref>https://html.spec.whatwg.org/multipage/comms.html</ref>.

-We created a corresponding websocket.rs file in the /servo/components/script/dom/ directory. In this file we have currently created a constructor that takes a url as an argument. We have a stub function to return the url that is used for initializing the web socket object through the constructor.

-We added The WebSocketTypeId to the struct in the eventtarget.rs file.

-We added the websocket module that we created to the lib.rs file.

-After making all the changes we build are changes into servo.

-Created a [https://github.com/servo/servo/pull/3813 pull request].

= Future Goals for the Project =

-Create a basic connection to the server using the websocket connection protocol as specified in the [http://tools.ietf.org/html/rfc6455#section-4.1 protocol spec].

-In order to allow writing more data to the existing socket connection, we plan to make the stream member in the BufferedResponse in rust-http public.

-Implement closing of connection along with on open and inclose events.

-Implement sending of short simple strings which fit within a single frame.

-Implement receiving of simple data and the on message event.

-Implement sending of fragmented data.

= Design Pattern =

We plan to implement the Factory<ref>http://en.wikipedia.org/wiki/Factory_(object-oriented_programming)</ref> design Pattern since out implementation of the WebSocket interface is a child of the EventTarget interface in servo.

= Appendix =

-Steps for [https://github.com/rust-lang/rust/wiki/Note-getting-started-developing-Rust Installing Rust] in detail.

-Steps for [https://github.com/servo/servo Building Servo] in detail.

=References=
<references/>

CSC/ECE 517 Fall 2014/OSS M1451 ahs

2014-10-30T00:58:18Z

Hmarfat: /* Design Pattern */

[https://docs.google.com/a/ncsu.edu/document/d/18VECpUuVmEaC4Xew4EsIAmOsRKdIeXaTA42tLlNwIho/edit Project Topic Page]
== Implement the WebSocket API ==
This wiki page contains details on the work done for the initial step of the task of [https://github.com/servo/servo/wiki/WebSocket-student-project Implement WebSocket API] for the Mozilla research project [http://github.com/servo/servo/wiki/Design Servo].

= Introduction =

== Rust <ref>http://en.wikipedia.org/wiki/Rust_(programming_language)</ref>==
Rust is a curly-brace, block-structured expression language.

*It visually resembles the C language family, but differs significantly in syntactic and semantic details.

*Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

*It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and
metaprogramming, in both static and dynamic styles.

*Example:
<pre>
fn main() {
println!("hello, world");
}
</pre>

== Servo <ref>http://en.wikipedia.org/wiki/Servo_(layout_engine)</ref> ==
Servo is an experimental web browser layout engine being developed by Mozilla.

*The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are
handled by fine-grained, isolated tasks.

*The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

*Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a
solid, embedded engine. Although Servo is a research project, it is designed to be "productisable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

== Task Architecture Diagrams<ref>https://github.com/servo/servo/wiki/Design#task-supervision-diagram</ref> ==

=== Task Supervision Diagram ===

[[File:TaskSupervision.png]]

=== Task Communication Diagram ===

[[File:TaskCommunication.png]]

=Implementation Steps=
We carried out the implementation for this project on a Mac machine. The steps we followed for the implementation are as follows:

== Compiling Rust ==
1. The initial step to build Servo required downloading and building the Rust compiler. To install Rust on the machine, clone the Rust source code from Mozilla's repository on GitHub using the following command:
<pre>
git clone git://github.com/mozilla/rust.git
cd rust
./configure
</pre>
2. Use the following commands to build the Rust compiler:
<pre>
make
make check
make install
</pre>

This will build and test the compiler, standard libraries, and supporting tools.

== Build Servo ==
1. Fork the servo repository and clone the source code into the local repository using the command:
<pre>
git clone https://github.com/servo/servo
</pre>
2. Build servo using the following commands:
<pre>
cd servo
./mach build
./mach run tests/html/about-mozilla.html
</pre>

== Part One Of the Project ==

-Created a WebSocket.webidl file in the /servo/components/script/dom/webidls/ directory. This file was added in order to create a new interface for the web socket.This interface is inherited from the EventTarget interface in servo.

-We added several attributes and methods to the WebSocket.webidl file which we plan to execute during the course of the project <ref>https://html.spec.whatwg.org/multipage/comms.html</ref>.

-We created a corresponding websocket.rs file in the /servo/components/script/dom/ directory. In this file we have currently created a constructor that takes a url as an argument. We have a stub function to return the url that is used for initializing the web socket object through the constructor.

-We added The WebSocketTypeId to the struct in the eventtarget.rs file.

-We added the websocket module that we created to the lib.rs file.

-After making all the changes we build are changes into servo.

= Future Goals for the Project =

-Create a basic connection to the server using the websocket connection protocol as specified in the [http://tools.ietf.org/html/rfc6455#section-4.1 protocol spec].

-In order to allow writing more data to the existing socket connection, we plan to make the stream member in the BufferedResponse in rust-http public.

-Implement closing of connection along with on open and inclose events.

-Implement sending of short simple strings which fit within a single frame.

-Implement receiving of simple data and the on message event.

-Implement sending of fragmented data.

= Design Pattern =

We plan to implement the Factory<ref>http://en.wikipedia.org/wiki/Factory_(object-oriented_programming)</ref> design Pattern since out implementation of the WebSocket interface is a child of the EventTarget interface in servo.

=References=
<references/>

CSC/ECE 517 Fall 2014/OSS M1451 ahs

2014-10-30T00:52:57Z

Hmarfat: /* Part One Of the Project */

[https://docs.google.com/a/ncsu.edu/document/d/18VECpUuVmEaC4Xew4EsIAmOsRKdIeXaTA42tLlNwIho/edit Project Topic Page]
== Implement the WebSocket API ==
This wiki page contains details on the work done for the initial step of the task of [https://github.com/servo/servo/wiki/WebSocket-student-project Implement WebSocket API] for the Mozilla research project [http://github.com/servo/servo/wiki/Design Servo].

= Introduction =

== Rust <ref>http://en.wikipedia.org/wiki/Rust_(programming_language)</ref>==
Rust is a curly-brace, block-structured expression language.

*It visually resembles the C language family, but differs significantly in syntactic and semantic details.

*Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

*It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and
metaprogramming, in both static and dynamic styles.

*Example:
<pre>
fn main() {
println!("hello, world");
}
</pre>

== Servo <ref>http://en.wikipedia.org/wiki/Servo_(layout_engine)</ref> ==
Servo is an experimental web browser layout engine being developed by Mozilla.

*The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are
handled by fine-grained, isolated tasks.

*The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

*Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a
solid, embedded engine. Although Servo is a research project, it is designed to be "productisable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

== Task Architecture Diagrams<ref>https://github.com/servo/servo/wiki/Design#task-supervision-diagram</ref> ==

=== Task Supervision Diagram ===

[[File:TaskSupervision.png]]

=== Task Communication Diagram ===

[[File:TaskCommunication.png]]

=Implementation Steps=
We carried out the implementation for this project on a Mac machine. The steps we followed for the implementation are as follows:

== Compiling Rust ==
1. The initial step to build Servo required downloading and building the Rust compiler. To install Rust on the machine, clone the Rust source code from Mozilla's repository on GitHub using the following command:
<pre>
git clone git://github.com/mozilla/rust.git
cd rust
./configure
</pre>
2. Use the following commands to build the Rust compiler:
<pre>
make
make check
make install
</pre>

This will build and test the compiler, standard libraries, and supporting tools.

== Build Servo ==
1. Fork the servo repository and clone the source code into the local repository using the command:
<pre>
git clone https://github.com/servo/servo
</pre>
2. Build servo using the following commands:
<pre>
cd servo
./mach build
./mach run tests/html/about-mozilla.html
</pre>

== Part One Of the Project ==

-Created a WebSocket.webidl file in the /servo/components/script/dom/webidls/ directory. This file was added in order to create a new interface for the web socket.This interface is inherited from the EventTarget interface in servo.

-We added several attributes and methods to the WebSocket.webidl file which we plan to execute during the course of the project <ref>https://html.spec.whatwg.org/multipage/comms.html</ref>.

-We created a corresponding websocket.rs file in the /servo/components/script/dom/ directory. In this file we have currently created a constructor that takes a url as an argument. We have a stub function to return the url that is used for initializing the web socket object through the constructor.

-We added The WebSocketTypeId to the struct in the eventtarget.rs file.

-We added the websocket module that we created to the lib.rs file.

-After making all the changes we build are changes into servo.

= Future Goals for the Project =

-Create a basic connection to the server using the websocket connection protocol as specified in the [http://tools.ietf.org/html/rfc6455#section-4.1 protocol spec].

-In order to allow writing more data to the existing socket connection, we plan to make the stream member in the BufferedResponse in rust-http public.

-Implement closing of connection along with on open and inclose events.

-Implement sending of short simple strings which fit within a single frame.

-Implement receiving of simple data and the on message event.

-Implement sending of fragmented data.

= Design Pattern =

=References=
<references/>

CSC/ECE 517 Fall 2014/OSS M1451 ahs

2014-10-30T00:52:01Z

Hmarfat: /* Future Goals for the Project */

[https://docs.google.com/a/ncsu.edu/document/d/18VECpUuVmEaC4Xew4EsIAmOsRKdIeXaTA42tLlNwIho/edit Project Topic Page]
== Implement the WebSocket API ==
This wiki page contains details on the work done for the initial step of the task of [https://github.com/servo/servo/wiki/WebSocket-student-project Implement WebSocket API] for the Mozilla research project [http://github.com/servo/servo/wiki/Design Servo].

= Introduction =

== Rust <ref>http://en.wikipedia.org/wiki/Rust_(programming_language)</ref>==
Rust is a curly-brace, block-structured expression language.

*It visually resembles the C language family, but differs significantly in syntactic and semantic details.

*Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

*It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and
metaprogramming, in both static and dynamic styles.

*Example:
<pre>
fn main() {
println!("hello, world");
}
</pre>

== Servo <ref>http://en.wikipedia.org/wiki/Servo_(layout_engine)</ref> ==
Servo is an experimental web browser layout engine being developed by Mozilla.

*The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are
handled by fine-grained, isolated tasks.

*The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

*Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a
solid, embedded engine. Although Servo is a research project, it is designed to be "productisable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

== Task Architecture Diagrams<ref>https://github.com/servo/servo/wiki/Design#task-supervision-diagram</ref> ==

=== Task Supervision Diagram ===

[[File:TaskSupervision.png]]

=== Task Communication Diagram ===

[[File:TaskCommunication.png]]

=Implementation Steps=
We carried out the implementation for this project on a Mac machine. The steps we followed for the implementation are as follows:

== Compiling Rust ==
1. The initial step to build Servo required downloading and building the Rust compiler. To install Rust on the machine, clone the Rust source code from Mozilla's repository on GitHub using the following command:
<pre>
git clone git://github.com/mozilla/rust.git
cd rust
./configure
</pre>
2. Use the following commands to build the Rust compiler:
<pre>
make
make check
make install
</pre>

This will build and test the compiler, standard libraries, and supporting tools.

== Build Servo ==
1. Fork the servo repository and clone the source code into the local repository using the command:
<pre>
git clone https://github.com/servo/servo
</pre>
2. Build servo using the following commands:
<pre>
cd servo
./mach build
./mach run tests/html/about-mozilla.html
</pre>

== Part One Of the Project ==

-Created a WebSocket.webidl file in the /servo/components/script/dom/webidls/ directory. This file was added in order to create a new interface for the web socket.This interface is inherited from the EventTarget interface in servo.

-We added several attributes and methods to the WebSocket.webidl file which we plan to execute during the course of the project.

-We created a corresponding websocket.rs file in the /servo/components/script/dom/ directory. In this file we have currently created a constructor that takes a url as an argument. We have a stub function to return the url that is used for initializing the web socket object through the constructor.

-We added The WebSocketTypeId to the struct in the eventtarget.rs file.

-We added the websocket module that we created to the lib.rs file.

-After making all the changes we build are changes into servo.

= Future Goals for the Project =

-Create a basic connection to the server using the websocket connection protocol as specified in the [http://tools.ietf.org/html/rfc6455#section-4.1 protocol spec].

-In order to allow writing more data to the existing socket connection, we plan to make the stream member in the BufferedResponse in rust-http public.

-Implement closing of connection along with on open and inclose events.

-Implement sending of short simple strings which fit within a single frame.

-Implement receiving of simple data and the on message event.

-Implement sending of fragmented data.

= Design Pattern =

=References=
<references/>

CSC/ECE 517 Fall 2014/OSS M1451 ahs

2014-10-30T00:51:32Z

Hmarfat: /* Future Goals for the Project */

[https://docs.google.com/a/ncsu.edu/document/d/18VECpUuVmEaC4Xew4EsIAmOsRKdIeXaTA42tLlNwIho/edit Project Topic Page]
== Implement the WebSocket API ==
This wiki page contains details on the work done for the initial step of the task of [https://github.com/servo/servo/wiki/WebSocket-student-project Implement WebSocket API] for the Mozilla research project [http://github.com/servo/servo/wiki/Design Servo].

= Introduction =

== Rust <ref>http://en.wikipedia.org/wiki/Rust_(programming_language)</ref>==
Rust is a curly-brace, block-structured expression language.

*It visually resembles the C language family, but differs significantly in syntactic and semantic details.

*Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

*It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and
metaprogramming, in both static and dynamic styles.

*Example:
<pre>
fn main() {
println!("hello, world");
}
</pre>

== Servo <ref>http://en.wikipedia.org/wiki/Servo_(layout_engine)</ref> ==
Servo is an experimental web browser layout engine being developed by Mozilla.

*The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are
handled by fine-grained, isolated tasks.

*The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

*Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a
solid, embedded engine. Although Servo is a research project, it is designed to be "productisable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

== Task Architecture Diagrams<ref>https://github.com/servo/servo/wiki/Design#task-supervision-diagram</ref> ==

=== Task Supervision Diagram ===

[[File:TaskSupervision.png]]

=== Task Communication Diagram ===

[[File:TaskCommunication.png]]

=Implementation Steps=
We carried out the implementation for this project on a Mac machine. The steps we followed for the implementation are as follows:

== Compiling Rust ==
1. The initial step to build Servo required downloading and building the Rust compiler. To install Rust on the machine, clone the Rust source code from Mozilla's repository on GitHub using the following command:
<pre>
git clone git://github.com/mozilla/rust.git
cd rust
./configure
</pre>
2. Use the following commands to build the Rust compiler:
<pre>
make
make check
make install
</pre>

This will build and test the compiler, standard libraries, and supporting tools.

== Build Servo ==
1. Fork the servo repository and clone the source code into the local repository using the command:
<pre>
git clone https://github.com/servo/servo
</pre>
2. Build servo using the following commands:
<pre>
cd servo
./mach build
./mach run tests/html/about-mozilla.html
</pre>

== Part One Of the Project ==

-Created a WebSocket.webidl file in the /servo/components/script/dom/webidls/ directory. This file was added in order to create a new interface for the web socket.This interface is inherited from the EventTarget interface in servo.

-We added several attributes and methods to the WebSocket.webidl file which we plan to execute during the course of the project.

-We created a corresponding websocket.rs file in the /servo/components/script/dom/ directory. In this file we have currently created a constructor that takes a url as an argument. We have a stub function to return the url that is used for initializing the web socket object through the constructor.

-We added The WebSocketTypeId to the struct in the eventtarget.rs file.

-We added the websocket module that we created to the lib.rs file.

-After making all the changes we build are changes into servo.

= Future Goals for the Project =

-Create a basic connection to the server using the websocket connection protocol as specified in the [http://tools.ietf.org/html/rfc6455#section-4.1].

-In order to allow writing more data to the existing socket connection, we plan to make the stream member in the BufferedResponse in rust-http public.

-Implement closing of connection along with on open and inclose events.

-Implement sending of short simple strings which fit within a single frame.

-Implement receiving of simple data and the on message event.

-Implement sending of fragmented data.

= Design Pattern =

=References=
<references/>

CSC/ECE 517 Fall 2014/OSS M1451 ahs

2014-10-30T00:50:56Z

Hmarfat: /* Future Goals for the Project */

[https://docs.google.com/a/ncsu.edu/document/d/18VECpUuVmEaC4Xew4EsIAmOsRKdIeXaTA42tLlNwIho/edit Project Topic Page]
== Implement the WebSocket API ==
This wiki page contains details on the work done for the initial step of the task of [https://github.com/servo/servo/wiki/WebSocket-student-project Implement WebSocket API] for the Mozilla research project [http://github.com/servo/servo/wiki/Design Servo].

= Introduction =

== Rust <ref>http://en.wikipedia.org/wiki/Rust_(programming_language)</ref>==
Rust is a curly-brace, block-structured expression language.

*It visually resembles the C language family, but differs significantly in syntactic and semantic details.

*Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

*It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and
metaprogramming, in both static and dynamic styles.

*Example:
<pre>
fn main() {
println!("hello, world");
}
</pre>

== Servo <ref>http://en.wikipedia.org/wiki/Servo_(layout_engine)</ref> ==
Servo is an experimental web browser layout engine being developed by Mozilla.

*The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are
handled by fine-grained, isolated tasks.

*The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

*Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a
solid, embedded engine. Although Servo is a research project, it is designed to be "productisable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

== Task Architecture Diagrams<ref>https://github.com/servo/servo/wiki/Design#task-supervision-diagram</ref> ==

=== Task Supervision Diagram ===

[[File:TaskSupervision.png]]

=== Task Communication Diagram ===

[[File:TaskCommunication.png]]

=Implementation Steps=
We carried out the implementation for this project on a Mac machine. The steps we followed for the implementation are as follows:

== Compiling Rust ==
1. The initial step to build Servo required downloading and building the Rust compiler. To install Rust on the machine, clone the Rust source code from Mozilla's repository on GitHub using the following command:
<pre>
git clone git://github.com/mozilla/rust.git
cd rust
./configure
</pre>
2. Use the following commands to build the Rust compiler:
<pre>
make
make check
make install
</pre>

This will build and test the compiler, standard libraries, and supporting tools.

== Build Servo ==
1. Fork the servo repository and clone the source code into the local repository using the command:
<pre>
git clone https://github.com/servo/servo
</pre>
2. Build servo using the following commands:
<pre>
cd servo
./mach build
./mach run tests/html/about-mozilla.html
</pre>

== Part One Of the Project ==

-Created a WebSocket.webidl file in the /servo/components/script/dom/webidls/ directory. This file was added in order to create a new interface for the web socket.This interface is inherited from the EventTarget interface in servo.

-We added several attributes and methods to the WebSocket.webidl file which we plan to execute during the course of the project.

-We created a corresponding websocket.rs file in the /servo/components/script/dom/ directory. In this file we have currently created a constructor that takes a url as an argument. We have a stub function to return the url that is used for initializing the web socket object through the constructor.

-We added The WebSocketTypeId to the struct in the eventtarget.rs file.

-We added the websocket module that we created to the lib.rs file.

-After making all the changes we build are changes into servo.

= Future Goals for the Project =

-Create a basic connection to the server using the websocket connection protocol [http://tools.ietf.org/html/rfc6455#section-4.1].

-In order to allow writing more data to the existing socket connection, we plan to make the stream member in the BufferedResponse in rust-http public.

-Implement closing of connection along with on open and inclose events.

-Implement sending of short simple strings which fit within a single frame.

-Implement receiving of simple data and the on message event.

-Implement sending of fragmented data.

= Design Pattern =

=References=
<references/>

CSC/ECE 517 Fall 2014/OSS M1451 ahs

2014-10-30T00:49:12Z

Hmarfat: /* Part One Of the Project */

[https://docs.google.com/a/ncsu.edu/document/d/18VECpUuVmEaC4Xew4EsIAmOsRKdIeXaTA42tLlNwIho/edit Project Topic Page]
== Implement the WebSocket API ==
This wiki page contains details on the work done for the initial step of the task of [https://github.com/servo/servo/wiki/WebSocket-student-project Implement WebSocket API] for the Mozilla research project [http://github.com/servo/servo/wiki/Design Servo].

= Introduction =

== Rust <ref>http://en.wikipedia.org/wiki/Rust_(programming_language)</ref>==
Rust is a curly-brace, block-structured expression language.

*It visually resembles the C language family, but differs significantly in syntactic and semantic details.

*Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

*It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and
metaprogramming, in both static and dynamic styles.

*Example:
<pre>
fn main() {
println!("hello, world");
}
</pre>

== Servo <ref>http://en.wikipedia.org/wiki/Servo_(layout_engine)</ref> ==
Servo is an experimental web browser layout engine being developed by Mozilla.

*The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are
handled by fine-grained, isolated tasks.

*The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

*Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a
solid, embedded engine. Although Servo is a research project, it is designed to be "productisable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

== Task Architecture Diagrams<ref>https://github.com/servo/servo/wiki/Design#task-supervision-diagram</ref> ==

=== Task Supervision Diagram ===

[[File:TaskSupervision.png]]

=== Task Communication Diagram ===

[[File:TaskCommunication.png]]

=Implementation Steps=
We carried out the implementation for this project on a Mac machine. The steps we followed for the implementation are as follows:

== Compiling Rust ==
1. The initial step to build Servo required downloading and building the Rust compiler. To install Rust on the machine, clone the Rust source code from Mozilla's repository on GitHub using the following command:
<pre>
git clone git://github.com/mozilla/rust.git
cd rust
./configure
</pre>
2. Use the following commands to build the Rust compiler:
<pre>
make
make check
make install
</pre>

This will build and test the compiler, standard libraries, and supporting tools.

== Build Servo ==
1. Fork the servo repository and clone the source code into the local repository using the command:
<pre>
git clone https://github.com/servo/servo
</pre>
2. Build servo using the following commands:
<pre>
cd servo
./mach build
./mach run tests/html/about-mozilla.html
</pre>

== Part One Of the Project ==

-Created a WebSocket.webidl file in the /servo/components/script/dom/webidls/ directory. This file was added in order to create a new interface for the web socket.This interface is inherited from the EventTarget interface in servo.

-We added several attributes and methods to the WebSocket.webidl file which we plan to execute during the course of the project.

-We created a corresponding websocket.rs file in the /servo/components/script/dom/ directory. In this file we have currently created a constructor that takes a url as an argument. We have a stub function to return the url that is used for initializing the web socket object through the constructor.

-We added The WebSocketTypeId to the struct in the eventtarget.rs file.

-We added the websocket module that we created to the lib.rs file.

-After making all the changes we build are changes into servo.

= Future Goals for the Project =

-Create a basic connection to the server using the websocket connection protocol[http://tools.ietf.org/html/rfc6455#section-4.1].

-In order to allow writing more data to the existing socket connection, we plan to make the stream member in the BufferedResponse in rust-http public.

-Implement closing of connection along with on open and inclose events.

-Implement sending of short simple strings which fit within a single frame.

-Implement receiving of simple data and the on message event.

-Implement sending of fragmented data.

= Design Pattern =

=References=
<references/>

CSC/ECE 517 Fall 2014/OSS M1451 ahs

2014-10-30T00:48:55Z

Hmarfat: /* Build Servo */

[https://docs.google.com/a/ncsu.edu/document/d/18VECpUuVmEaC4Xew4EsIAmOsRKdIeXaTA42tLlNwIho/edit Project Topic Page]
== Implement the WebSocket API ==
This wiki page contains details on the work done for the initial step of the task of [https://github.com/servo/servo/wiki/WebSocket-student-project Implement WebSocket API] for the Mozilla research project [http://github.com/servo/servo/wiki/Design Servo].

= Introduction =

== Rust <ref>http://en.wikipedia.org/wiki/Rust_(programming_language)</ref>==
Rust is a curly-brace, block-structured expression language.

*It visually resembles the C language family, but differs significantly in syntactic and semantic details.

*Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

*It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and
metaprogramming, in both static and dynamic styles.

*Example:
<pre>
fn main() {
println!("hello, world");
}
</pre>

== Servo <ref>http://en.wikipedia.org/wiki/Servo_(layout_engine)</ref> ==
Servo is an experimental web browser layout engine being developed by Mozilla.

*The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are
handled by fine-grained, isolated tasks.

*The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

*Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a
solid, embedded engine. Although Servo is a research project, it is designed to be "productisable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

== Task Architecture Diagrams<ref>https://github.com/servo/servo/wiki/Design#task-supervision-diagram</ref> ==

=== Task Supervision Diagram ===

[[File:TaskSupervision.png]]

=== Task Communication Diagram ===

[[File:TaskCommunication.png]]

=Implementation Steps=
We carried out the implementation for this project on a Mac machine. The steps we followed for the implementation are as follows:

== Compiling Rust ==
1. The initial step to build Servo required downloading and building the Rust compiler. To install Rust on the machine, clone the Rust source code from Mozilla's repository on GitHub using the following command:
<pre>
git clone git://github.com/mozilla/rust.git
cd rust
./configure
</pre>
2. Use the following commands to build the Rust compiler:
<pre>
make
make check
make install
</pre>

This will build and test the compiler, standard libraries, and supporting tools.

== Build Servo ==
1. Fork the servo repository and clone the source code into the local repository using the command:
<pre>
git clone https://github.com/servo/servo
</pre>
2. Build servo using the following commands:
<pre>
cd servo
./mach build
./mach run tests/html/about-mozilla.html
</pre>

== Part One Of the Project ==

-Created a WebSocket.webidl file in the /servo/components/script/dom/webidls/ directory. This file was added in order to create a new interface for the web socket.This interface is inherited from the EventTarget interface in servo.

-We added several attributes and methods to the WebSocket.webidl file which we plan to execute during the course of the project.

-We created a corresponding websocket.rs file in the /servo/components/script/dom/ directory. In this file we have currently created a constructor that takes a url as an argument. We have a stub function to return the url that is used for initializing the web socket object through the constructor.

-We added The WebSocketTypeId to the struct in the eventtarget.rs file.

-We added the websocket module that we created to the lib.rs file.

-After making all the changes we build are changes into servo.

= Future Goals for the Project =

-Create a basic connection to the server using the websocket connection protocol[http://tools.ietf.org/html/rfc6455#section-4.1].

-In order to allow writing more data to the existing socket connection, we plan to make the stream member in the BufferedResponse in rust-http public.

-Implement closing of connection along with on open and inclose events.

-Implement sending of short simple strings which fit within a single frame.

-Implement receiving of simple data and the on message event.

-Implement sending of fragmented data.

= Design Pattern =

=References=
<references/>

CSC/ECE 517 Fall 2014/OSS M1451 ahs

2014-10-30T00:48:40Z

Hmarfat: /* Compiling Rust */

[https://docs.google.com/a/ncsu.edu/document/d/18VECpUuVmEaC4Xew4EsIAmOsRKdIeXaTA42tLlNwIho/edit Project Topic Page]
== Implement the WebSocket API ==
This wiki page contains details on the work done for the initial step of the task of [https://github.com/servo/servo/wiki/WebSocket-student-project Implement WebSocket API] for the Mozilla research project [http://github.com/servo/servo/wiki/Design Servo].

= Introduction =

== Rust <ref>http://en.wikipedia.org/wiki/Rust_(programming_language)</ref>==
Rust is a curly-brace, block-structured expression language.

*It visually resembles the C language family, but differs significantly in syntactic and semantic details.

*Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

*It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and
metaprogramming, in both static and dynamic styles.

*Example:
<pre>
fn main() {
println!("hello, world");
}
</pre>

== Servo <ref>http://en.wikipedia.org/wiki/Servo_(layout_engine)</ref> ==
Servo is an experimental web browser layout engine being developed by Mozilla.

*The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are
handled by fine-grained, isolated tasks.

*The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

*Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a
solid, embedded engine. Although Servo is a research project, it is designed to be "productisable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

== Task Architecture Diagrams<ref>https://github.com/servo/servo/wiki/Design#task-supervision-diagram</ref> ==

=== Task Supervision Diagram ===

[[File:TaskSupervision.png]]

=== Task Communication Diagram ===

[[File:TaskCommunication.png]]

=Implementation Steps=
We carried out the implementation for this project on a Mac machine. The steps we followed for the implementation are as follows:

== Compiling Rust ==
1. The initial step to build Servo required downloading and building the Rust compiler. To install Rust on the machine, clone the Rust source code from Mozilla's repository on GitHub using the following command:
<pre>
git clone git://github.com/mozilla/rust.git
cd rust
./configure
</pre>
2. Use the following commands to build the Rust compiler:
<pre>
make
make check
make install
</pre>

This will build and test the compiler, standard libraries, and supporting tools.

==Build Servo==
1. Fork the servo repository and clone the source code into the local repository using the command:
<pre>
git clone https://github.com/servo/servo
</pre>
2. Build servo using the following commands:
<pre>
cd servo
./mach build
./mach run tests/html/about-mozilla.html
</pre>

== Part One Of the Project ==

-Created a WebSocket.webidl file in the /servo/components/script/dom/webidls/ directory. This file was added in order to create a new interface for the web socket.This interface is inherited from the EventTarget interface in servo.

-We added several attributes and methods to the WebSocket.webidl file which we plan to execute during the course of the project.

-We created a corresponding websocket.rs file in the /servo/components/script/dom/ directory. In this file we have currently created a constructor that takes a url as an argument. We have a stub function to return the url that is used for initializing the web socket object through the constructor.

-We added The WebSocketTypeId to the struct in the eventtarget.rs file.

-We added the websocket module that we created to the lib.rs file.

-After making all the changes we build are changes into servo.

= Future Goals for the Project =

-Create a basic connection to the server using the websocket connection protocol[http://tools.ietf.org/html/rfc6455#section-4.1].

-In order to allow writing more data to the existing socket connection, we plan to make the stream member in the BufferedResponse in rust-http public.

-Implement closing of connection along with on open and inclose events.

-Implement sending of short simple strings which fit within a single frame.

-Implement receiving of simple data and the on message event.

-Implement sending of fragmented data.

= Design Pattern =

=References=
<references/>

CSC/ECE 517 Fall 2014/OSS M1451 ahs

2014-10-30T00:48:01Z

Hmarfat: /* Future Goals for the Project */

[https://docs.google.com/a/ncsu.edu/document/d/18VECpUuVmEaC4Xew4EsIAmOsRKdIeXaTA42tLlNwIho/edit Project Topic Page]
== Implement the WebSocket API ==
This wiki page contains details on the work done for the initial step of the task of [https://github.com/servo/servo/wiki/WebSocket-student-project Implement WebSocket API] for the Mozilla research project [http://github.com/servo/servo/wiki/Design Servo].

= Introduction =

== Rust <ref>http://en.wikipedia.org/wiki/Rust_(programming_language)</ref>==
Rust is a curly-brace, block-structured expression language.

*It visually resembles the C language family, but differs significantly in syntactic and semantic details.

*Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

*It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and
metaprogramming, in both static and dynamic styles.

*Example:
<pre>
fn main() {
println!("hello, world");
}
</pre>

== Servo <ref>http://en.wikipedia.org/wiki/Servo_(layout_engine)</ref> ==
Servo is an experimental web browser layout engine being developed by Mozilla.

*The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are
handled by fine-grained, isolated tasks.

*The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

*Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a
solid, embedded engine. Although Servo is a research project, it is designed to be "productisable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

== Task Architecture Diagrams<ref>https://github.com/servo/servo/wiki/Design#task-supervision-diagram</ref> ==

=== Task Supervision Diagram ===

[[File:TaskSupervision.png]]

=== Task Communication Diagram ===

[[File:TaskCommunication.png]]

=Implementation Steps=
We carried out the implementation for this project on a Mac machine. The steps we followed for the implementation are as follows:

==Compiling Rust==
1. The initial step to build Servo required downloading and building the Rust compiler. To install Rust on the machine, clone the Rust source code from Mozilla's repository on GitHub using the following command:
<pre>
git clone git://github.com/mozilla/rust.git
cd rust
./configure
</pre>
2. Use the following commands to build the Rust compiler:
<pre>
make
make check
make install
</pre>

This will build and test the compiler, standard libraries, and supporting tools.
==Build Servo==
1. Fork the servo repository and clone the source code into the local repository using the command:
<pre>
git clone https://github.com/servo/servo
</pre>
2. Build servo using the following commands:
<pre>
cd servo
./mach build
./mach run tests/html/about-mozilla.html
</pre>

== Part One Of the Project ==

-Created a WebSocket.webidl file in the /servo/components/script/dom/webidls/ directory. This file was added in order to create a new interface for the web socket.This interface is inherited from the EventTarget interface in servo.

-We added several attributes and methods to the WebSocket.webidl file which we plan to execute during the course of the project.

-We created a corresponding websocket.rs file in the /servo/components/script/dom/ directory. In this file we have currently created a constructor that takes a url as an argument. We have a stub function to return the url that is used for initializing the web socket object through the constructor.

-We added The WebSocketTypeId to the struct in the eventtarget.rs file.

-We added the websocket module that we created to the lib.rs file.

-After making all the changes we build are changes into servo.

= Future Goals for the Project =

-Create a basic connection to the server using the websocket connection protocol[http://tools.ietf.org/html/rfc6455#section-4.1].

-In order to allow writing more data to the existing socket connection, we plan to make the stream member in the BufferedResponse in rust-http public.

-Implement closing of connection along with on open and inclose events.

-Implement sending of short simple strings which fit within a single frame.

-Implement receiving of simple data and the on message event.

-Implement sending of fragmented data.

= Design Pattern =

=References=
<references/>

CSC/ECE 517 Fall 2014/OSS M1451 ahs

2014-10-30T00:47:26Z

Hmarfat:

[https://docs.google.com/a/ncsu.edu/document/d/18VECpUuVmEaC4Xew4EsIAmOsRKdIeXaTA42tLlNwIho/edit Project Topic Page]
== Implement the WebSocket API ==
This wiki page contains details on the work done for the initial step of the task of [https://github.com/servo/servo/wiki/WebSocket-student-project Implement WebSocket API] for the Mozilla research project [http://github.com/servo/servo/wiki/Design Servo].

= Introduction =

== Rust <ref>http://en.wikipedia.org/wiki/Rust_(programming_language)</ref>==
Rust is a curly-brace, block-structured expression language.

*It visually resembles the C language family, but differs significantly in syntactic and semantic details.

*Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

*It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and
metaprogramming, in both static and dynamic styles.

*Example:
<pre>
fn main() {
println!("hello, world");
}
</pre>

== Servo <ref>http://en.wikipedia.org/wiki/Servo_(layout_engine)</ref> ==
Servo is an experimental web browser layout engine being developed by Mozilla.

*The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are
handled by fine-grained, isolated tasks.

*The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

*Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a
solid, embedded engine. Although Servo is a research project, it is designed to be "productisable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

== Task Architecture Diagrams<ref>https://github.com/servo/servo/wiki/Design#task-supervision-diagram</ref> ==

=== Task Supervision Diagram ===

[[File:TaskSupervision.png]]

=== Task Communication Diagram ===

[[File:TaskCommunication.png]]

=Implementation Steps=
We carried out the implementation for this project on a Mac machine. The steps we followed for the implementation are as follows:

==Compiling Rust==
1. The initial step to build Servo required downloading and building the Rust compiler. To install Rust on the machine, clone the Rust source code from Mozilla's repository on GitHub using the following command:
<pre>
git clone git://github.com/mozilla/rust.git
cd rust
./configure
</pre>
2. Use the following commands to build the Rust compiler:
<pre>
make
make check
make install
</pre>

This will build and test the compiler, standard libraries, and supporting tools.
==Build Servo==
1. Fork the servo repository and clone the source code into the local repository using the command:
<pre>
git clone https://github.com/servo/servo
</pre>
2. Build servo using the following commands:
<pre>
cd servo
./mach build
./mach run tests/html/about-mozilla.html
</pre>

== Part One Of the Project ==

-Created a WebSocket.webidl file in the /servo/components/script/dom/webidls/ directory. This file was added in order to create a new interface for the web socket.This interface is inherited from the EventTarget interface in servo.

-We added several attributes and methods to the WebSocket.webidl file which we plan to execute during the course of the project.

-We created a corresponding websocket.rs file in the /servo/components/script/dom/ directory. In this file we have currently created a constructor that takes a url as an argument. We have a stub function to return the url that is used for initializing the web socket object through the constructor.

-We added The WebSocketTypeId to the struct in the eventtarget.rs file.

-We added the websocket module that we created to the lib.rs file.

-After making all the changes we build are changes into servo.

= Future Goals for the Project =

-Create a basic connection to the server using the websocket connection protocol[http://tools.ietf.org/html/rfc6455#section-4.1]
-In order to allow writing more data to the existing socket connection, we plan to make the stream member in the BufferedResponse in rust-http public.
-Implement closing of connection along with on open and inclose events.
-Implement sending of short simple strings which fit within a single frame.
-Implement receiving of simple data and the on message event.
-Implement sending of fragmented data.

= Design Pattern =

=References=
<references/>

CSC/ECE 517 Fall 2014/OSS M1451 ahs

2014-10-30T00:34:31Z

Hmarfat: /* Part One Of the Project */

[https://docs.google.com/a/ncsu.edu/document/d/18VECpUuVmEaC4Xew4EsIAmOsRKdIeXaTA42tLlNwIho/edit Project Topic Page]
== Implement the WebSocket API ==
This wiki page contains details on the work done for the initial step of the task of [https://github.com/servo/servo/wiki/WebSocket-student-project Implement WebSocket API] for the Mozilla research project [http://github.com/servo/servo/wiki/Design Servo].

= Introduction =

== Rust <ref>http://en.wikipedia.org/wiki/Rust_(programming_language)</ref>==
Rust is a curly-brace, block-structured expression language.

*It visually resembles the C language family, but differs significantly in syntactic and semantic details.

*Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

*It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and
metaprogramming, in both static and dynamic styles.

*Example:
<pre>
fn main() {
println!("hello, world");
}
</pre>

== Servo <ref>http://en.wikipedia.org/wiki/Servo_(layout_engine)</ref> ==
Servo is an experimental web browser layout engine being developed by Mozilla.

*The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are
handled by fine-grained, isolated tasks.

*The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

*Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a
solid, embedded engine. Although Servo is a research project, it is designed to be "productisable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

== Task Architecture Diagrams<ref>https://github.com/servo/servo/wiki/Design#task-supervision-diagram</ref> ==

=== Task Supervision Diagram ===

[[File:TaskSupervision.png]]

=== Task Communication Diagram ===

[[File:TaskCommunication.png]]

=Implementation Steps=
We carried out the implementation for this project on a Mac machine. The steps we followed for the implementation are as follows:

==Compiling Rust==
1. The initial step to build Servo required downloading and building the Rust compiler. To install Rust on the machine, clone the Rust source code from Mozilla's repository on GitHub using the following command:
<pre>
git clone git://github.com/mozilla/rust.git
cd rust
./configure
</pre>
2. Use the following commands to build the Rust compiler:
<pre>
make
make check
make install
</pre>

This will build and test the compiler, standard libraries, and supporting tools.
==Build Servo==
1. Fork the servo repository and clone the source code into the local repository using the command:
<pre>
git clone https://github.com/servo/servo
</pre>
2. Build servo using the following commands:
<pre>
cd servo
./mach build
./mach run tests/html/about-mozilla.html
</pre>

== Part One Of the Project ==

-Created a WebSocket.webidl file in the /servo/components/script/dom/webidls/ directory. This file was added in order to create a new interface for the web socket.This interface is inherited from the EventTarget interface in servo.

-We added several attributes and methods to the WebSocket.webidl file which we plan to execute during the course of the project.

-We created a corresponding websocket.rs file in the /servo/components/script/dom/ directory. In this file we have currently created a constructor that takes a url as an argument. We have a stub function to return the url that is used for initializing the web socket object through the constructor.

-We added The WebSocketTypeId to the struct in the eventtarget.rs file.

-We added the websocket module that we created to the lib.rs file.

-After making all the changes we build are changes into servo.

=References=
<references/>

CSC/ECE 517 Fall 2014/OSS M1451 ahs

2014-10-30T00:33:36Z

Hmarfat: /* Implementation Steps */

[https://docs.google.com/a/ncsu.edu/document/d/18VECpUuVmEaC4Xew4EsIAmOsRKdIeXaTA42tLlNwIho/edit Project Topic Page]
== Implement the WebSocket API ==
This wiki page contains details on the work done for the initial step of the task of [https://github.com/servo/servo/wiki/WebSocket-student-project Implement WebSocket API] for the Mozilla research project [http://github.com/servo/servo/wiki/Design Servo].

= Introduction =

== Rust <ref>http://en.wikipedia.org/wiki/Rust_(programming_language)</ref>==
Rust is a curly-brace, block-structured expression language.

*It visually resembles the C language family, but differs significantly in syntactic and semantic details.

*Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

*It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and
metaprogramming, in both static and dynamic styles.

*Example:
<pre>
fn main() {
println!("hello, world");
}
</pre>

== Servo <ref>http://en.wikipedia.org/wiki/Servo_(layout_engine)</ref> ==
Servo is an experimental web browser layout engine being developed by Mozilla.

*The prototype seeks to create a highly parallel environment, in which many components (such as rendering, layout, HTML parsing, image decoding, etc.) are
handled by fine-grained, isolated tasks.

*The project has a symbiotic relationship with the Rust programming language, in which it is being developed.

*Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a
solid, embedded engine. Although Servo is a research project, it is designed to be "productisable"—the code that we write should be of high enough quality that it could eventually be shipped to users.

== Task Architecture Diagrams<ref>https://github.com/servo/servo/wiki/Design#task-supervision-diagram</ref> ==

=== Task Supervision Diagram ===

[[File:TaskSupervision.png]]

=== Task Communication Diagram ===

[[File:TaskCommunication.png]]

=Implementation Steps=
We carried out the implementation for this project on a Mac machine. The steps we followed for the implementation are as follows:

==Compiling Rust==
1. The initial step to build Servo required downloading and building the Rust compiler. To install Rust on the machine, clone the Rust source code from Mozilla's repository on GitHub using the following command:
<pre>
git clone git://github.com/mozilla/rust.git
cd rust
./configure
</pre>
2. Use the following commands to build the Rust compiler:
<pre>
make
make check
make install
</pre>

This will build and test the compiler, standard libraries, and supporting tools.
==Build Servo==
1. Fork the servo repository and clone the source code into the local repository using the command:
<pre>
git clone https://github.com/servo/servo
</pre>
2. Build servo using the following commands:
<pre>
cd servo
./mach build
./mach run tests/html/about-mozilla.html
</pre>

== Part One Of the Project ==
-Created a WebSocket.webidl file in the /servo/components/script/dom/webidls/ directory. This file was added in order to create a new interface for the web socket. This interface is inherited from the EventTarget interface in servo.
-We added several attributes and methods to the WebSocket.webidl file which we plan to execute during the course of the project.
-We created a corresponding websocket.rs file in the /servo/components/script/dom/ directory. In this file we have currently created a constructor that takes a url as an argument. We have a stub function to return the url that is used for initializing the web socket object through the constructor.
-We added The WebSocketTypeId to the struct in the eventtarget.rs file.
-We added the websocket module that we created to the lib.rs file.
-After making all the changes we build are changes into servo.

=References=
<references/>

CSC/ECE 517 Fall 2014/OSS M1451 ahs

2014-10-30T00:19:59Z

Hmarfat:

CSC/ECE 517 Fall 2014/OSS M1451 ahs

2014-10-30T00:18:25Z

Hmarfat:

File:TaskCommunication.png

2014-10-30T00:15:43Z

Hmarfat:

File:TaskSupervision.png

2014-10-30T00:15:30Z

Hmarfat:

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-26T01:25:19Z

Hmarfat: /* Additional References */

==''' Go Programming Language''' ==
'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by [https://golang.org/cmd/gc Gc] compiler of Go.

__TOC__

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

= Comparison between Go Programming and C++ Programming language <ref name="KTH">[http://www.csc.kth.se/utbildning/kth/kurser/DD143X/dkand11/Group9Alexander/Joakim_Anneback_Johan_Stjernberg.finalreport.2.pdf KTH comparison]</ref><ref name="quora">[http://www.quora.com/How-does-Go-compare-to-C++-and-Java Quora comparison]</ref><ref name="Scriptol">[http://www.scriptol.com/programming/go.php scriptol]</ref>=
Go programming language was developed to run as fast as C++ programs while adding a lot of other modern day features. Some of the key differeneces are listed below

{| class="wikitable" border="2"
! scope="col" | Points of Comparison
! scope="col" | Go Programming Language
! scope="col" | C++ Programming Language
|-
|
'''Primary Focus'''
|| Go focuses on garbage collection, concurrency and compiling quickly
|| C++ focuses on inheritance, generic types and pointer arithmetics.
|-
|
'''Variable Sizes'''
|| Machine-independent types are now included without an import needed: int8, int16, int32, int64, uint8, etc.
|| Machine-dependent variable sizes
|-
|
'''Class Hierarchies'''
|| Inheritance is not supported , but with the traditional structures with plain old functions and namespaces, is a MUCH
better, more flexible approach that leads to better, more maintainable code.
|| Inheritance is supported but it has its own share of problems like diamond inheritance, virtual inheritance and normal inheritance.
|-
|
'''Function overloading'''
|| Not present in Go because it simplifies dispatch.
|| Present in C++.
|-
|
'''Genrics'''
|| Go does not currently support generic types. However, it does support objects without a type using the empty interface.
|| C++ on the other hand has support for generic types. Generic programming is supported by the use of function templates, class templates and, in some cases, specialized templates in C++.
|-
|
'''Multithreading'''
|| Goroutines are Go's model of threads/coroutines. Each new goroutine runs in parallel with the current computation, in "the same address space. Goroutines are cheap and developers need not to
worry about the stack size.
|| In contrast, there is currently no built-in way to manage threads in C++, although the feature is expected in the upcoming new standard and is already today possible using third-party libraries.
|-
|
'''Garbage Collection'''
|| Go uses garbage collection for memory management, which means that if frees the programmer completely from keeping a track on the memory used.
|| C++ does not have any garbage collection and hence relies heavily on that the programmer knows what he or she is doing.
|-
|}

=Language Design<ref name = "GoLang Book">[http://www.golang-book.com, GoLang Book]</ref>=

==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

The program above depicts the basic syntax of a program written using Go. Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details (go vet and go link perform checking automatically).
* Using tools and libraries provided in Go, there are standard approaches for API documentation (go doc), testing (go test), building( go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String literals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string. Example below illustrates these functions.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: e
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop are to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using go func().
* Channel types are used for providing type safe and synchronized channels between different go routines.

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c .<ref name = "GoWIKI">[http://en.wikipedia.org/wiki/Go_(programming_language), Wikipedia]</ref>

=Advantages<ref name="csdn"> [http://blog.csdn.net/lymemoryzz/article/details/20960997 CSDN blog]</ref>=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.<ref name = "Limitations1"/>

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.<ref name = "Google_FAQ"/>
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />
=Additional References=
*[http://tour.golang.org Golang tour]
*[http://golangtutorials.blogspot.com/2011/05/table-of-contents.html Golang tutorials]
*[http://go.googlecode.com/hg-history/release-branch.r60/doc/GoCourseDay1.pdf GoCourseDay1]
*[https://www.youtube.com/watch?v=rKnDgT73v8s Go programming language tutorial video]

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-26T01:15:19Z

Hmarfat:

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-26T00:58:33Z

Hmarfat: /* Concurrency */

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-26T00:55:48Z

Hmarfat: /* Control Structures */

==''' Go Programming Language''' ==
'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by [https://golang.org/cmd/gc Gc] compiler of Go.

__TOC__

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

= Comparison between Go Programming and C++ Programming language <ref name="KTH">[http://www.csc.kth.se/utbildning/kth/kurser/DD143X/dkand11/Group9Alexander/Joakim_Anneback_Johan_Stjernberg.finalreport.2.pdf KTH comparison]</ref><ref name="quora">[http://www.quora.com/How-does-Go-compare-to-C++-and-Java Quora comparison]</ref><ref name="Scriptol">[http://www.scriptol.com/programming/go.php scriptol]</ref>=
Go programming language was developed to run as fast as C++ programs while adding a lot of other modern day features. Some of the key differeneces are listed below

{| class="wikitable" border="2"
! scope="col" | Points of Comparison
! scope="col" | Go Programming Language
! scope="col" | C++ Programming Language
|-
|
'''Primary Focus'''
|| Go focuses on garbage collection, concurrency and compiling quickly
|| C++ focuses on inheritance, generic types and pointer arithmetics.
|-
|
'''Variable Sizes'''
|| Machine-independent types are now included without an import needed: int8, int16, int32, int64, uint8, etc.
|| Machine-dependent variable sizes
|-
|
'''Class Hierarchies'''
|| Inheritance is not supported , but with the traditional structures with plain old functions and namespaces, is a MUCH
better, more flexible approach that leads to better, more maintainable code.
|| Inheritance is supported but it has its own share of problems like diamond inheritance, virtual inheritance and normal inheritance.
|-
|
'''Function overloading'''
|| Not present in Go because it simplifies dispatch.
|| Present in C++.
|-
|
'''Genrics'''
|| Go does not currently support generic types. However, it does support objects without a type using the empty interface.
|| C++ on the other hand has support for generic types. Generic programming is supported by the use of function templates, class templates and, in some cases, specialized templates in C++.
|-
|
'''Multithreading'''
|| Goroutines are Go's model of threads/coroutines. Each new goroutine runs in parallel with the current computation, in "the same address space. Goroutines are cheap and developers need not to
worry about the stack size.
|| In contrast, there is currently no built-in way to manage threads in C++, although the feature is expected in the upcoming new standard and is already today possible using third-party libraries.
|-
|
'''Garbage Collection'''
|| Go uses garbage collection for memory management, which means that if frees the programmer completely from keeping a track on the memory used.
|| C++ does not have any garbage collection and hence relies heavily on that the programmer knows what he or she is doing.
|-
|}

=Language Design<ref name = "GoLang Book">[http://www.golang-book.com, GoLang Book]</ref>=

==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

The program above depicts the basic syntax of a program written using Go. Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details (go vet and go link perform checking automatically).
* Using tools and libraries provided in Go, there are standard approaches for API documentation (go doc), testing (go test), building( go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String literals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string. Example below illustrates these functions.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: e
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop are to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using go fund()
* Channel types are used for providing type safe and synchronized channels between different go routines.

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c .<ref name = "GoWIKI">[http://en.wikipedia.org/wiki/Go_(programming_language), Wikipedia]</ref>

=Advantages<ref name="csdn"> [http://blog.csdn.net/lymemoryzz/article/details/20960997 CSDN blog]</ref>=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.<ref name = "Limitations1"/>

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.<ref name = "Google_FAQ"/>
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-26T00:53:48Z

Hmarfat: /* Types */

==''' Go Programming Language''' ==
'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by [https://golang.org/cmd/gc Gc] compiler of Go.

__TOC__

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

= Comparison between Go Programming and C++ Programming language <ref name="KTH">[http://www.csc.kth.se/utbildning/kth/kurser/DD143X/dkand11/Group9Alexander/Joakim_Anneback_Johan_Stjernberg.finalreport.2.pdf KTH comparison]</ref><ref name="quora">[http://www.quora.com/How-does-Go-compare-to-C++-and-Java Quora comparison]</ref><ref name="Scriptol">[http://www.scriptol.com/programming/go.php scriptol]</ref>=
Go programming language was developed to run as fast as C++ programs while adding a lot of other modern day features. Some of the key differeneces are listed below

{| class="wikitable" border="2"
! scope="col" | Points of Comparison
! scope="col" | Go Programming Language
! scope="col" | C++ Programming Language
|-
|
'''Primary Focus'''
|| Go focuses on garbage collection, concurrency and compiling quickly
|| C++ focuses on inheritance, generic types and pointer arithmetics.
|-
|
'''Variable Sizes'''
|| Machine-independent types are now included without an import needed: int8, int16, int32, int64, uint8, etc.
|| Machine-dependent variable sizes
|-
|
'''Class Hierarchies'''
|| Inheritance is not supported , but with the traditional structures with plain old functions and namespaces, is a MUCH
better, more flexible approach that leads to better, more maintainable code.
|| Inheritance is supported but it has its own share of problems like diamond inheritance, virtual inheritance and normal inheritance.
|-
|
'''Function overloading'''
|| Not present in Go because it simplifies dispatch.
|| Present in C++.
|-
|
'''Genrics'''
|| Go does not currently support generic types. However, it does support objects without a type using the empty interface.
|| C++ on the other hand has support for generic types. Generic programming is supported by the use of function templates, class templates and, in some cases, specialized templates in C++.
|-
|
'''Multithreading'''
|| Goroutines are Go's model of threads/coroutines. Each new goroutine runs in parallel with the current computation, in "the same address space. Goroutines are cheap and developers need not to
worry about the stack size.
|| In contrast, there is currently no built-in way to manage threads in C++, although the feature is expected in the upcoming new standard and is already today possible using third-party libraries.
|-
|
'''Garbage Collection'''
|| Go uses garbage collection for memory management, which means that if frees the programmer completely from keeping a track on the memory used.
|| C++ does not have any garbage collection and hence relies heavily on that the programmer knows what he or she is doing.
|-
|}

=Language Design<ref name = "GoLang Book">[http://www.golang-book.com, GoLang Book]</ref>=

==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

The program above depicts the basic syntax of a program written using Go. Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details (go vet and go link perform checking automatically).
* Using tools and libraries provided in Go, there are standard approaches for API documentation (go doc), testing (go test), building( go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String literals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string. Example below illustrates these functions.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: e
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using go fund()
* Channel types are used for providing type safe and synchronized channels between different go routines.

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c .<ref name = "GoWIKI">[http://en.wikipedia.org/wiki/Go_(programming_language), Wikipedia]</ref>

=Advantages<ref name="csdn"> [http://blog.csdn.net/lymemoryzz/article/details/20960997 CSDN blog]</ref>=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.<ref name = "Limitations1"/>

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.<ref name = "Google_FAQ"/>
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-26T00:53:01Z

Hmarfat: /* Types */

==''' Go Programming Language''' ==
'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by [https://golang.org/cmd/gc Gc] compiler of Go.

__TOC__

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

= Comparison between Go Programming and C++ Programming language <ref name="KTH">[http://www.csc.kth.se/utbildning/kth/kurser/DD143X/dkand11/Group9Alexander/Joakim_Anneback_Johan_Stjernberg.finalreport.2.pdf KTH comparison]</ref><ref name="quora">[http://www.quora.com/How-does-Go-compare-to-C++-and-Java Quora comparison]</ref><ref name="Scriptol">[http://www.scriptol.com/programming/go.php scriptol]</ref>=
Go programming language was developed to run as fast as C++ programs while adding a lot of other modern day features. Some of the key differeneces are listed below

{| class="wikitable" border="2"
! scope="col" | Points of Comparison
! scope="col" | Go Programming Language
! scope="col" | C++ Programming Language
|-
|
'''Primary Focus'''
|| Go focuses on garbage collection, concurrency and compiling quickly
|| C++ focuses on inheritance, generic types and pointer arithmetics.
|-
|
'''Variable Sizes'''
|| Machine-independent types are now included without an import needed: int8, int16, int32, int64, uint8, etc.
|| Machine-dependent variable sizes
|-
|
'''Class Hierarchies'''
|| Inheritance is not supported , but with the traditional structures with plain old functions and namespaces, is a MUCH
better, more flexible approach that leads to better, more maintainable code.
|| Inheritance is supported but it has its own share of problems like diamond inheritance, virtual inheritance and normal inheritance.
|-
|
'''Function overloading'''
|| Not present in Go because it simplifies dispatch.
|| Present in C++.
|-
|
'''Genrics'''
|| Go does not currently support generic types. However, it does support objects without a type using the empty interface.
|| C++ on the other hand has support for generic types. Generic programming is supported by the use of function templates, class templates and, in some cases, specialized templates in C++.
|-
|
'''Multithreading'''
|| Goroutines are Go's model of threads/coroutines. Each new goroutine runs in parallel with the current computation, in "the same address space. Goroutines are cheap and developers need not to
worry about the stack size.
|| In contrast, there is currently no built-in way to manage threads in C++, although the feature is expected in the upcoming new standard and is already today possible using third-party libraries.
|-
|
'''Garbage Collection'''
|| Go uses garbage collection for memory management, which means that if frees the programmer completely from keeping a track on the memory used.
|| C++ does not have any garbage collection and hence relies heavily on that the programmer knows what he or she is doing.
|-
|}

=Language Design<ref name = "GoLang Book">[http://www.golang-book.com, GoLang Book]</ref>=

==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

The program above depicts the basic syntax of a program written using Go. Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details (go vet and go link perform checking automatically).
* Using tools and libraries provided in Go, there are standard approaches for API documentation (go doc), testing (go test), building( go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String literals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string. Example below illustrates these functions.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: 1
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using go fund()
* Channel types are used for providing type safe and synchronized channels between different go routines.

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c .<ref name = "GoWIKI">[http://en.wikipedia.org/wiki/Go_(programming_language), Wikipedia]</ref>

=Advantages<ref name="csdn"> [http://blog.csdn.net/lymemoryzz/article/details/20960997 CSDN blog]</ref>=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.<ref name = "Limitations1"/>

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.<ref name = "Google_FAQ"/>
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-26T00:51:51Z

Hmarfat: /* Code Conventions and Style */

==''' Go Programming Language''' ==
'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by [https://golang.org/cmd/gc Gc] compiler of Go.

__TOC__

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

= Comparison between Go Programming and C++ Programming language <ref name="KTH">[http://www.csc.kth.se/utbildning/kth/kurser/DD143X/dkand11/Group9Alexander/Joakim_Anneback_Johan_Stjernberg.finalreport.2.pdf KTH comparison]</ref><ref name="quora">[http://www.quora.com/How-does-Go-compare-to-C++-and-Java Quora comparison]</ref><ref name="Scriptol">[http://www.scriptol.com/programming/go.php scriptol]</ref>=
Go programming language was developed to run as fast as C++ programs while adding a lot of other modern day features. Some of the key differeneces are listed below

{| class="wikitable" border="2"
! scope="col" | Points of Comparison
! scope="col" | Go Programming Language
! scope="col" | C++ Programming Language
|-
|
'''Primary Focus'''
|| Go focuses on garbage collection, concurrency and compiling quickly
|| C++ focuses on inheritance, generic types and pointer arithmetics.
|-
|
'''Variable Sizes'''
|| Machine-independent types are now included without an import needed: int8, int16, int32, int64, uint8, etc.
|| Machine-dependent variable sizes
|-
|
'''Class Hierarchies'''
|| Inheritance is not supported , but with the traditional structures with plain old functions and namespaces, is a MUCH
better, more flexible approach that leads to better, more maintainable code.
|| Inheritance is supported but it has its own share of problems like diamond inheritance, virtual inheritance and normal inheritance.
|-
|
'''Function overloading'''
|| Not present in Go because it simplifies dispatch.
|| Present in C++.
|-
|
'''Genrics'''
|| Go does not currently support generic types. However, it does support objects without a type using the empty interface.
|| C++ on the other hand has support for generic types. Generic programming is supported by the use of function templates, class templates and, in some cases, specialized templates in C++.
|-
|
'''Multithreading'''
|| Goroutines are Go's model of threads/coroutines. Each new goroutine runs in parallel with the current computation, in "the same address space. Goroutines are cheap and developers need not to
worry about the stack size.
|| In contrast, there is currently no built-in way to manage threads in C++, although the feature is expected in the upcoming new standard and is already today possible using third-party libraries.
|-
|
'''Garbage Collection'''
|| Go uses garbage collection for memory management, which means that if frees the programmer completely from keeping a track on the memory used.
|| C++ does not have any garbage collection and hence relies heavily on that the programmer knows what he or she is doing.
|-
|}

=Language Design<ref name = "GoLang Book">[http://www.golang-book.com, GoLang Book]</ref>=

==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

The program above depicts the basic syntax of a program written using Go. Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details (go vet and go link perform checking automatically).
* Using tools and libraries provided in Go, there are standard approaches for API documentation (go doc), testing (go test), building( go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String litersals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: 1
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using go fund()
* Channel types are used for providing type safe and synchronized channels between different go routines.

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c .<ref name = "GoWIKI">[http://en.wikipedia.org/wiki/Go_(programming_language), Wikipedia]</ref>

=Advantages<ref name="csdn"> [http://blog.csdn.net/lymemoryzz/article/details/20960997 CSDN blog]</ref>=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.<ref name = "Limitations1"/>

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.<ref name = "Google_FAQ"/>
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-26T00:50:51Z

Hmarfat: /* Syntax */

==''' Go Programming Language''' ==
'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by [https://golang.org/cmd/gc Gc] compiler of Go.

__TOC__

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

= Comparison between Go Programming and C++ Programming language <ref name="KTH">[http://www.csc.kth.se/utbildning/kth/kurser/DD143X/dkand11/Group9Alexander/Joakim_Anneback_Johan_Stjernberg.finalreport.2.pdf KTH comparison]</ref><ref name="quora">[http://www.quora.com/How-does-Go-compare-to-C++-and-Java Quora comparison]</ref><ref name="Scriptol">[http://www.scriptol.com/programming/go.php scriptol]</ref>=
Go programming language was developed to run as fast as C++ programs while adding a lot of other modern day features. Some of the key differeneces are listed below

{| class="wikitable" border="2"
! scope="col" | Points of Comparison
! scope="col" | Go Programming Language
! scope="col" | C++ Programming Language
|-
|
'''Primary Focus'''
|| Go focuses on garbage collection, concurrency and compiling quickly
|| C++ focuses on inheritance, generic types and pointer arithmetics.
|-
|
'''Variable Sizes'''
|| Machine-independent types are now included without an import needed: int8, int16, int32, int64, uint8, etc.
|| Machine-dependent variable sizes
|-
|
'''Class Hierarchies'''
|| Inheritance is not supported , but with the traditional structures with plain old functions and namespaces, is a MUCH
better, more flexible approach that leads to better, more maintainable code.
|| Inheritance is supported but it has its own share of problems like diamond inheritance, virtual inheritance and normal inheritance.
|-
|
'''Function overloading'''
|| Not present in Go because it simplifies dispatch.
|| Present in C++.
|-
|
'''Genrics'''
|| Go does not currently support generic types. However, it does support objects without a type using the empty interface.
|| C++ on the other hand has support for generic types. Generic programming is supported by the use of function templates, class templates and, in some cases, specialized templates in C++.
|-
|
'''Multithreading'''
|| Goroutines are Go's model of threads/coroutines. Each new goroutine runs in parallel with the current computation, in "the same address space. Goroutines are cheap and developers need not to
worry about the stack size.
|| In contrast, there is currently no built-in way to manage threads in C++, although the feature is expected in the upcoming new standard and is already today possible using third-party libraries.
|-
|
'''Garbage Collection'''
|| Go uses garbage collection for memory management, which means that if frees the programmer completely from keeping a track on the memory used.
|| C++ does not have any garbage collection and hence relies heavily on that the programmer knows what he or she is doing.
|-
|}

=Language Design<ref name = "GoLang Book">[http://www.golang-book.com, GoLang Book]</ref>=

==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

The program above depicts the basic syntax of a program written using Go. Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details. go vet and go link are perform checking automatically.
* Using tools and libraries provided in Go, there are standard approaches for API documentation(go doc), testing(go test), building(go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally in C++) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String litersals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: 1
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using go fund()
* Channel types are used for providing type safe and synchronized channels between different go routines.

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c .<ref name = "GoWIKI">[http://en.wikipedia.org/wiki/Go_(programming_language), Wikipedia]</ref>

=Advantages<ref name="csdn"> [http://blog.csdn.net/lymemoryzz/article/details/20960997 CSDN blog]</ref>=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.<ref name = "Limitations1"/>

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.<ref name = "Google_FAQ"/>
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-26T00:49:50Z

Hmarfat: /* Comparison between Go Programming and C++ Programming language KTH comparisonQuora comparisonscriptol */

==''' Go Programming Language''' ==
'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by [https://golang.org/cmd/gc Gc] compiler of Go.

__TOC__

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

= Comparison between Go Programming and C++ Programming language <ref name="KTH">[http://www.csc.kth.se/utbildning/kth/kurser/DD143X/dkand11/Group9Alexander/Joakim_Anneback_Johan_Stjernberg.finalreport.2.pdf KTH comparison]</ref><ref name="quora">[http://www.quora.com/How-does-Go-compare-to-C++-and-Java Quora comparison]</ref><ref name="Scriptol">[http://www.scriptol.com/programming/go.php scriptol]</ref>=
Go programming language was developed to run as fast as C++ programs while adding a lot of other modern day features. Some of the key differeneces are listed below

{| class="wikitable" border="2"
! scope="col" | Points of Comparison
! scope="col" | Go Programming Language
! scope="col" | C++ Programming Language
|-
|
'''Primary Focus'''
|| Go focuses on garbage collection, concurrency and compiling quickly
|| C++ focuses on inheritance, generic types and pointer arithmetics.
|-
|
'''Variable Sizes'''
|| Machine-independent types are now included without an import needed: int8, int16, int32, int64, uint8, etc.
|| Machine-dependent variable sizes
|-
|
'''Class Hierarchies'''
|| Inheritance is not supported , but with the traditional structures with plain old functions and namespaces, is a MUCH
better, more flexible approach that leads to better, more maintainable code.
|| Inheritance is supported but it has its own share of problems like diamond inheritance, virtual inheritance and normal inheritance.
|-
|
'''Function overloading'''
|| Not present in Go because it simplifies dispatch.
|| Present in C++.
|-
|
'''Genrics'''
|| Go does not currently support generic types. However, it does support objects without a type using the empty interface.
|| C++ on the other hand has support for generic types. Generic programming is supported by the use of function templates, class templates and, in some cases, specialized templates in C++.
|-
|
'''Multithreading'''
|| Goroutines are Go's model of threads/coroutines. Each new goroutine runs in parallel with the current computation, in "the same address space. Goroutines are cheap and developers need not to
worry about the stack size.
|| In contrast, there is currently no built-in way to manage threads in C++, although the feature is expected in the upcoming new standard and is already today possible using third-party libraries.
|-
|
'''Garbage Collection'''
|| Go uses garbage collection for memory management, which means that if frees the programmer completely from keeping a track on the memory used.
|| C++ does not have any garbage collection and hence relies heavily on that the programmer knows what he or she is doing.
|-
|}

=Language Design<ref name = "GoLang Book">[http://www.golang-book.com, GoLang Book]</ref>=

==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details. go vet and go link are perform checking automatically.
* Using tools and libraries provided in Go, there are standard approaches for API documentation(go doc), testing(go test), building(go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally in C++) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String litersals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: 1
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using go fund()
* Channel types are used for providing type safe and synchronized channels between different go routines.

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c .<ref name = "GoWIKI">[http://en.wikipedia.org/wiki/Go_(programming_language), Wikipedia]</ref>

=Advantages<ref name="csdn"> [http://blog.csdn.net/lymemoryzz/article/details/20960997 CSDN blog]</ref>=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.<ref name = "Limitations1"/>

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.<ref name = "Google_FAQ"/>
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-26T00:47:21Z

Hmarfat:

==''' Go Programming Language''' ==
'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by [https://golang.org/cmd/gc Gc] compiler of Go.

__TOC__

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

= Comparison between Go Programming and C++ Programming language <ref name="KTH">[http://www.csc.kth.se/utbildning/kth/kurser/DD143X/dkand11/Group9Alexander/Joakim_Anneback_Johan_Stjernberg.finalreport.2.pdf KTH comparison]</ref><ref name="quora">[http://www.quora.com/How-does-Go-compare-to-C++-and-Java Quora comparison]</ref><ref name="Scriptol">[http://www.scriptol.com/programming/go.php scriptol]</ref>=
Go programming language was developed to run as fast of C++ programs while adding a lot of other modern day features. Some of the key differeneces are listed below

{| class="wikitable" border="2"
! scope="col" | Points of Comparison
! scope="col" | Go Programming Language
! scope="col" | C++ Programming Language
|-
|
'''Primary Focus'''
|| Go focuses on garbage collection, concurrency and compiling quickly
|| C++ focuses on inheritance, generic types and pointer arithmetics.
|-
|
'''Variable Sizes'''
|| Machine-independent types are now included without an import needed: int8, int16, int32, int64, uint8, etc.
|| Machine-dependent variable sizes
|-
|
'''Class Hierarchies'''
|| Inheritance is not supported , but with the traditional structures with plain old functions and namespaces, is a MUCH
better, more flexible approach that leads to better, more maintainable code.
|| Inheritance is supported but it has its own share of problems like diamond inheritance, virtual inheritance and normal inheritance.
|-
|
'''Function overloading'''
|| Not present in Go because it simplifies dispatch.
|| Present in C++.
|-
|
'''Genrics'''
|| Go does not currently support generic types. However, it does support objects without a type using the empty interface.
|| C++ on the other hand has support for generic types. Generic programming is supported by the use of function templates, class templates and, in some cases, specialized templates in C++.
|-
|
'''Multithreading'''
|| Goroutines are Go's model of threads/coroutines. Each new goroutine runs in parallel with the current computation, in "the same address space. Goroutines are cheap and developers need not to
worry about the stack size.
|| In contrast, there is currently no built-in way to manage threads in C++, although the feature is expected in the upcoming new standard and is already today possible using third-party libraries.
|-
|
'''Garbage Collection'''
|| Go uses garbage collection for memory management, which means that if frees the programmer completely from keeping a track on the memory used.
|| C++ does not have any garbage collection and hence relies heavily on that the programmer knows what he or she is doing.
|-
|}

=Language Design<ref name = "GoLang Book">[http://www.golang-book.com, GoLang Book]</ref>=

==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details. go vet and go link are perform checking automatically.
* Using tools and libraries provided in Go, there are standard approaches for API documentation(go doc), testing(go test), building(go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally in C++) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String litersals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: 1
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using go fund()
* Channel types are used for providing type safe and synchronized channels between different go routines.

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c .<ref name = "GoWIKI">[http://en.wikipedia.org/wiki/Go_(programming_language), Wikipedia]</ref>

=Advantages<ref name="csdn"> [http://blog.csdn.net/lymemoryzz/article/details/20960997 CSDN blog]</ref>=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.<ref name = "Limitations1"/>

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.<ref name = "Google_FAQ"/>
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-20T01:39:52Z

Hmarfat: /* Go Programming Language */

==''' Go Programming Language''' ==
'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) Garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by [https://golang.org/cmd/gc Gc] compiler of Go.

__TOC__

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Language Design<ref name = "GoLang Book">[http://www.golang-book.com, GoLang Book]</ref>=

==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details. go vet and go link are perform checking automatically.
* Using tools and libraries provided in Go, there are standard approaches for API documentation(go doc), testing(go test), building(go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally in C++) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String litersals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: 1
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using go fund()
* Channel types are used for providing type safe and synchronized channels between different go routines.

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c .<ref name = "GoWIKI">[http://en.wikipedia.org/wiki/Go_(programming_language), Wikipedia]</ref>

=Advantages=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.<ref name = "Limitations1"/>

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-20T01:35:46Z

Hmarfat:

==''' Go Programming Language''' ==
'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) Garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by gc compiler of Go.

__TOC__

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Language Design<ref name = "GoLang Book">[http://www.golang-book.com, GoLang Book]</ref>=

==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details. go vet and go link are perform checking automatically.
* Using tools and libraries provided in Go, there are standard approaches for API documentation(go doc), testing(go test), building(go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally in C++) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String litersals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: 1
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using go fund()
* Channel types are used for providing type safe and synchronized channels between different go routines.

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c .<ref name = "GoWIKI">[http://en.wikipedia.org/wiki/Go_(programming_language), Wikipedia]</ref>

=Advantages=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.<ref name = "Limitations1"/>

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-20T01:32:16Z

Hmarfat:

==''' Go Programming Language''' ==

'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) Garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by gc compiler of Go.

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Language Design<ref name = "GoLang Book">[http://www.golang-book.com, GoLang Book]</ref>=

==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details. go vet and go link are perform checking automatically.
* Using tools and libraries provided in Go, there are standard approaches for API documentation(go doc), testing(go test), building(go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally in C++) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String litersals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: 1
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using go fund()
* Channel types are used for providing type safe and synchronized channels between different go routines.

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c .<ref name = "GoWIKI">[http://en.wikipedia.org/wiki/Go_(programming_language), Wikipedia]</ref>

=Advantages=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.<ref name = "Limitations1"/>

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-20T01:31:21Z

Hmarfat: /* Go Programming Language by Google */

'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) Garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by gc compiler of Go.

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Language Design<ref name = "GoLang Book">[http://www.golang-book.com, GoLang Book]</ref>=

==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details. go vet and go link are perform checking automatically.
* Using tools and libraries provided in Go, there are standard approaches for API documentation(go doc), testing(go test), building(go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally in C++) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String litersals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: 1
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using go fund()
* Channel types are used for providing type safe and synchronized channels between different go routines.

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c .<ref name = "GoWIKI">[http://en.wikipedia.org/wiki/Go_(programming_language), Wikipedia]</ref>

=Advantages=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.<ref name = "Limitations1"/>

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-20T01:30:09Z

Hmarfat: /* Go Programming Language by Google */

= Go Programming Language by Google =

'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) Garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by gc compiler of Go.

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Language Design<ref name = "GoLang Book">[http://www.golang-book.com, GoLang Book]</ref>=

==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details. go vet and go link are perform checking automatically.
* Using tools and libraries provided in Go, there are standard approaches for API documentation(go doc), testing(go test), building(go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally in C++) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String litersals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: 1
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using go fund()
* Channel types are used for providing type safe and synchronized channels between different go routines.

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c .<ref name = "GoWIKI">[http://en.wikipedia.org/wiki/Go_(programming_language), Wikipedia]</ref>

=Advantages=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.<ref name = "Limitations1"/>

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-20T01:29:38Z

Hmarfat:

== Go Programming Language by Google ==

'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) Garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by gc compiler of Go.

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Language Design<ref name = "GoLang Book">[http://www.golang-book.com, GoLang Book]</ref>=

==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details. go vet and go link are perform checking automatically.
* Using tools and libraries provided in Go, there are standard approaches for API documentation(go doc), testing(go test), building(go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally in C++) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String litersals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: 1
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using go fund()
* Channel types are used for providing type safe and synchronized channels between different go routines.

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c .<ref name = "GoWIKI">[http://en.wikipedia.org/wiki/Go_(programming_language), Wikipedia]</ref>

=Advantages=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.<ref name = "Limitations1"/>

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-20T01:20:56Z

Hmarfat: /* Concurrency */

'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) Garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by gc compiler of Go.

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Language Design=
<ref name = "GoLang Book">[http://www.golang-book.com, GoLang Book]</ref>
==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details. go vet and go link are perform checking automatically.
* Using tools and libraries provided in Go, there are standard approaches for API documentation(go doc), testing(go test), building(go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally in C++) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String litersals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: 1
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using go fund()
* Channel types are used for providing type safe and synchronized channels between different go routines.

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c .<ref name = "GoWIKI">[http://en.wikipedia.org/wiki/Go_(programming_language), Wikipedia]</ref>

=Advantages=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-20T01:14:18Z

Hmarfat: /* Concurrency */

'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) Garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by gc compiler of Go.

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Language Design=
==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details. go vet and go link are perform checking automatically.
* Using tools and libraries provided in Go, there are standard approaches for API documentation(go doc), testing(go test), building(go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally in C++) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String litersals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: 1
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using go fund()
* Channel types are used for providing

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c .<ref name = "GoWIKI">[http://en.wikipedia.org/wiki/Go_(programming_language), Wikipedia]</ref>

=Advantages=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-20T01:11:26Z

Hmarfat:

'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) Garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Different operating systems like Linux, Microsoft Windows, Mac OS X are suported by gc compiler of Go.

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language Introduction speech]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Language Design=
==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details. go vet and go link are perform checking automatically.
* Using tools and libraries provided in Go, there are standard approaches for API documentation(go doc), testing(go test), building(go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally in C++) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String litersals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: 1
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c

=Advantages=

*'''C Level Performance'''. golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-20T01:03:17Z

Hmarfat: /* Concurrency */

'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) Garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Go's "gc" compiler targets the [http://en.wikipedia.org/wiki/Linux Linux], [http://en.wikipedia.org/wiki/OS_X OS X], [http://en.wikipedia.org/wiki/FreeBSD FreeBSD], [http://en.wikipedia.org/wiki/NetBSD NetBSD], [http://en.wikipedia.org/wiki/OpenBSD OpenBSD], and [http://en.wikipedia.org/wiki/Microsoft_Windows Microsoft Windows] operating systems and the i386, amd64, and ARM processor architectures.

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs.<ref name = "Background 1">[https://www.youtube.com/watch?v=rKnDgT73v8s Go Language release]</ref> So they wanted to come up with a new systems focused programming language that would address the above issues.<ref name="BG2">[http://techcrunch.com/2009/11/10/google-go-language TechCrunch]</ref> They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, [http://research.google.com/pubs/author37504.html Ian Taylor] independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. [http://russ.cox.usesthis.com/ Russ Cox] joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public [http://en.wikipedia.org/wiki/Open_source open source project] on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.<ref name = "Google_FAQ"/>

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.<ref name = "Google_FAQ"/>

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.<ref name = "Google_FAQ">[https://golang.org/doc/faq golang FAQs]</ref>

=Language Design=
==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details. go vet and go link are perform checking automatically.
* Using tools and libraries provided in Go, there are standard approaches for API documentation(go doc), testing(go test), building(go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally in C++) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String litersals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: 1
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multithreading and CPU parallelization.
* Go supports asynchrony i.e. allows operations like database and network I/O which are slow operations to occur in parallel along with other operations.
* A new lightweight process is created using

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c

=Advantages=

C Level Performance -- golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />

CSC/ECE 517 Fall 2014/ch1a 10 hu

2014-09-20T00:45:20Z

Hmarfat: /* Concurrency */

'''Go''', also commonly referred to as '''golang''', is a compiled, concurrent, garbage-collected, statically typed language developed at [http://en.wikipedia.org/wiki/Google Google]. It was developed by [http://en.wikipedia.org/wiki/Robert_Griesemer Robert Griesemer], [http://en.wikipedia.org/wiki/Rob_Pike Rob Pike] and [http://en.wikipedia.org/wiki/Ken_Thompson Ken Thompson] in 2007. It was announced in November 2009 and is currently being used in many production systems at Google. It is an open source project. The syntax is loosely derived from that of [http://en.wikipedia.org/wiki/C_(programming_language) C programming language], adding [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) Garbage collection], type safety, some dynamic-typing capabilities. Additional built-in types such as variable-length arrays and key-value maps, and a large standard library are also supported. Go's "gc" compiler targets the [http://en.wikipedia.org/wiki/Linux Linux], [http://en.wikipedia.org/wiki/OS_X OS X], [http://en.wikipedia.org/wiki/FreeBSD FreeBSD], [http://en.wikipedia.org/wiki/NetBSD NetBSD], [http://en.wikipedia.org/wiki/OpenBSD OpenBSD], and [http://en.wikipedia.org/wiki/Microsoft_Windows Microsoft Windows] operating systems and the i386, amd64, and ARM processor architectures.

=Background=

Go programming started of as a research project by Robert Griesemer, Rob Pike and Ken Thompson. They felt that there was no new system focused programming language that has come up in the last decade till 2008, while there were other developments like increase in the size of libraries, dominance of networking , client server focus, multi-core CPUs. So they wanted to come up with a new systems focused programming language that would address the above issues. They started sketching the goals for a new language on the white board on September 21, 2007. Within a few days the goals had settled into a plan to do something and a fair idea of what it would be. Design continued part-time in parallel with unrelated work.
By January 2008, Ken had started work on a compiler with which to explore ideas; it generated C code as its output. By mid-year the language had become a full-time project and had settled enough to attempt a production compiler. In May 2008, Ian Taylor independently started on a [http://en.wikipedia.org/wiki/GNU_Compiler_Collection GCC] front end for Go using the draft specification. Russ Cox joined in late 2008 and helped move the language and libraries from prototype to reality.
Go became a public open source project on November 10, 2009. Many people from the community have contributed ideas, discussions, and code.

=Compilers and Runtime support=

There are two Go compiler implementations, [https://golang.org/cmd/gc Gc] (the 6g program and friends) and [http://blog.golang.org/gccgo-in-gcc-471 gccgo ]. Gc uses a different calling convention and linker. It can therefore only be linked with C programs using the same convention. Gccgo is a GCC front-end that can be linked with GCC-compiled C or C++ programs.

The cgo program provides the mechanism for a “foreign function interface” to allow safe calling of C libraries from Go code. [http://en.wikipedia.org/wiki/SWIG SWIG] extends this capability to C++ libraries.

Again due to bootstrapping issues, the run-time code is mostly in C (with a tiny bit of assembler) although Go is capable of implementing most of it now. Gccgo's run-time support uses glibc. Gc uses a custom library to keep the footprint under control; it is compiled with a version of the [http://plan9.bell-labs.com/sys/doc/compiler.html Plan 9 C compiler] that supports resizable stacks for goroutines. The gccgo compiler implements these on Linux only, using a technique called segmented stacks, supported by recent modifications to the gold linker.

You can find all resources needed to compile and run Go Language here http://go-lang.cat-v.org/

=Design Principles=

Programming today involves too much bookkeeping, repetition, and clerical work. As Dick Gabriel says, “Old programs read like quiet conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who'd have guessed sophistication bought such noise?” The sophistication is worthwhile—no one wants to go back to the old languages—but can it be more quietly achieved?

Go attempts to reduce the amount of typing in both senses of the word. Throughout its design,
*They have tried to reduce clutter and complexity.
*There are no forward declarations and no header files. everything is declared exactly once.
*Initialization is expressive, automatic, and easy to use.
*Syntax is clean and light on keywords. Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.
*And perhaps most radically, there is no type hierarchy. They don't have to announce their relationships.

These simplifications allow Go to be expressive yet comprehensible without sacrificing, well, sophistication.
Another important principle is to keep the concepts orthogonal. Methods can be implemented for any type; structures represent data while interfaces represent abstraction; and so on. Orthogonality makes it easier to understand what happens when things combine.

=Language Design=
==Syntax==

<pre>
package main //line 1

import “fmt” //line 2

func main() { //line 3

fmt.Println(“Hello World”) //line 4

} //line 5
</pre>

Line1 specifies package declaration. Package is used to organize and reuse code. Line 2 is used for including the package “fmt” which is used for formatting input and output. Line 3 to 5 defines the function main. main is the function which is called when a program is executed. Println function in fmt is used to display content to the console i.e in this example Hello World is displayed in the console on executing the program.

==Code Conventions and Style==

* Go fmt tool is used to automatically standardize indentation, spaces and surface-level code details. go vet and go link are perform checking automatically.
* Using tools and libraries provided in Go, there are standard approaches for API documentation(go doc), testing(go test), building(go build) and package management(go get).
* Syntax prevents any kind of cyclic dependencies.
* Unused variables and imports are not allowed.
* Elimination of functional programming constructs (such as map and try/finally in C++) ensure a concrete and explicit programming style.

==Types==

* Numbers are represented in Go as either Integers or Floating point numbers.
**Integers: Used to represent numbers without a decimal component. Different integers supported by Go are: uint8, uint16, uint32, uint64, int8, int16, int32, int64. Uint is used for unsigned integers and int for signed. 8,16, 32, 64 indicate the number of bits each type would use.
**Floating Point Integers: Used to support decimal components. Go supports float32 and float64 to represent floating point numbers and complex32 and complex64 to represent complex numbers.

Example:

<pre>
var x int32 =4
var y float32 = 4.5
</pre>

* String: String litersals can be created using either double quotes(“Hello”) or back ticks(`Hello`). Strings have several operations associated them, for example one can find the length of the string or get a character at a specific index in a string.

Example:

<pre>
package main

import “fmt”

func main() {

fmt.Println(len(“Hello”)) // output: 5
fmt.Println(“Hello”[1]) // output: 1
fmt.Println(“Hello “+”Tom”) //output: Hello Tom

}

</pre>

* Boolean: A 1 bit value is used to represent true or false.

==Variables and Constants==
*Variabes in Go are indicated using the var keyword. Example: var x string=”hello” . They can also be shorthanded as x:=”hello” .
*The variable names should begin with a letter and can contain letters, digits or underscore character.
*The scope of the variable is the block in which it is defined and an attempt to access it outside the block would result in an error on running the program.
*Go provides support for constants (i.e. variables whose value can not be changed), using the const keyword. Example: const temp string = “Hello”
*In Go one can define multiple variables(or constants) using the following syntax:
var(
t1 =1
t2=2
t3=3
t4=4
)

==Control Structures==
*For: It is used for repeating a list of statement(s) multiple times. The example below is used for calculating sum of numbers from 1 to 10.

<pre>

package main

import “fmt”

func main() {

i := 1
sum := 0

for i <= 10 {
sum = sum + i
i = i + 1
}

fmt.Println(“Sum:” + sum)
}

</pre>

In the example above i is a loop counter variable and is used to ensure that sum of numbers from 1 to 10 is computed. It indicates the number of times the statements inside the for loop is to be executed. The statement following the keyword for should evaluate to either true or false. If it is evaluated to true the body of for is executed, else we come out of the for loop.

*If: Used to execute a block of statement(s) based on the evaluation of an expression to either true or false. It can also have an else associated with it.

Example:

<pre>

package main

import “fmt”

func main(){

if i % 2 == 0 {
fmt.Println(i + ” is divisble by 2”)
} else {
fmt.Println(i + “is not divisible by 2”)
}

}

</pre>

*Switch: The value of the expression following switch is evaluated and is compared against the different cases. Based on the matching case, the block following that case is executed. Switch also has a default case in situations when none of the cases are matching.

Example:

<pre>

package main

import “fmt”

func main(){

// if op ==1 then so a+b
// if op == 2 then do a-b
// if op == 3 then do a*b
// if op ==4 then do a/b
// default print, invalid operator

op:= 1
a=6
b=7
switch(op) {
case 1: fmt.Println(a+b)
case 2: fmt.Println(a-b)
case 3: fmt.Println(a*b)
case 4: fmt.Println(a/b)
default: fmt.Println(“Invalid Operator”)
}

}
</pre>

==Arrays, Slices and Maps==

*Arrays: Numbered sequence of elements starting with index zero and each of the elements having a fixed length. The example below illustrates various operations performed on arrays in Go.

<pre>

package main

import “fmt”

func main() {

var x[10] int
x[99]=100
fmt.Println(x) //[0 0 ….. 0 100]
fmt.Println(len(x)) //100

}

</pre>

*Slices:
** It is a segment of an array.
** They have a length and are indexable.
**In case of a slice the size does not have to specified in the square bracket.
**Slices support two in-build functions: copy and append.
**The program below illustrates the different ways to create slices and use of copy and append.

<pre>

package main

import “fmt”

func main() {

arr := [10] int {1,2,3,4,5,6,7,8,9,10}
x := make([]int,10) // creates a slice [1...10]
y := make([]int,10,10) //creates a slice [1...10]
z := arr[0:10] //creates a slice [1...10]
s1 := []int{1,2,3,4,5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1,2,3,4,5]
fmt.Println(s2) // [1,2,3,4,5,6,7]
p1 := [] int{1,2,3,4,5}
p2 :=make([]int, 4)
copy(p2,p1)
fmt.Println(p1) // [1,2,3,4,5]
fmt.Println(p2)// [1,2,3,4]
}

</pre>

*Maps:
**A map is an unordered collection of key value pairs.
**Syntax: var x map[int] string , where int is the type of the key and string is the type of the value.

Example

<pre>

package main

import “fmt”

func main(){

x := make(map[int]string)
x[1] = one
x[2] = two

}

</pre>

==Functions==

*In Go functions can take multiple inputs and return multiple outputs.
*Go supports a special kind of function called variadic function.
*Closure is the means by which functions can be created inside other function in Go.
*Go supports recursive functions.
*The example below the different types of function in Go.

<pre>
package main

import “fmt”

func main(){

display(“Hello World”)
sum :=calculateSum(10,20)
v1,v2=multipleValues()
p=product(5,10,20)
}

// function without return type
func display( s string) {
fmt.Println(s)
}

// function which returns a single value
func calculateSum(a int, b int) int {
c: = a + b
return c
}

// function which returns multiple values
func multipleValues(int, int) {
return 1, 2
}

//Variadic function
func product(args ...int) int {
p := 1
for _, i := range args {
p *= i
}
return p
}

</pre>

==Pointers==
It is used to reference a location in the memory where the value is stored rather than containing the value itself. Basic pointer operations in Go are illustrated in the example below.

<pre>

package main

import “fmt”

func main(){

//Different syntax for pointers

ptr1 *int
num :=10
ptr1 = &num
ptr2 := new(int)
ptr2=&num

}

</pre>

==Concurrency==
* Go ensures concurrency which allows sharing of state using communication mechanisms.
* Go provides support for multi

=Users of Go=
Apart from Google, which uses Go programming for some of its development, companies like [http://en.wikipedia.org/wiki/Dropbox_(service) Dropbox], [http://en.wikipedia.org/wiki/CloudFlare CloudFlare], [http://en.wikipedia.org/wiki/SoundCloud SoundCloud], The BBC, Novartis, Cloud Foundry also use Go programming.
Dropbox server (running in the cloud) and desktop client software were primarily written in [http://en.wikipedia.org/wiki/Python_(programming_language) Python]. From mid-2013 Dropbox began migrating its backend infrastructure to Go.
Some of the open-source applications that are using Go programming are Docker, Flynn, PaaS, Juju, nsq, Doozer e.t.c

=Advantages=

C Level Performance -- golang is within a close margin of the performance level of C code (which is itself an extremely high performance language). It is certainly closer to the performance of native languages than other enterprise level languages such as Java, Scala, Erlang etc.

*'''Fast Compilation''' is one of the key advantages of Go language. The Golang compiler was designed to compile programs very quickly. Extremely large programs with massively high LOC counts compile seemingly instantly - after all, Golang was designed by Google to solve Google problems, and Google has big problems! At Google, code and CPU cores are both measured in the millions. Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.

Reduced compile time is a key improvement in the Go language
<pre>
If A.go depends on B.go depends on C.go :
Compile C.go, B.go then A.go normally (other languages)
To compile A.go, compiler reads B.o not C.o (go)
</pre>

At a large scale this should help in hugely speeding up

Other advantages are
* '''Concurrency Supported At Language Level'''. Concurrency is the ability to execute multiple computations simultaneously. In today's modern multicore and high-load computing environment, concurrency is a critical language feature, and one in which languages such as Java struggle immensely.
* By its design, Go proposes an approach for the construction of system software on '''multicore machines'''.
* Google have summed things up nicely with their motto: '''Don't communicate by sharing memory, share memory by communicating'''.Channels allow you to pass references to data structures between goroutines. If you consider this as passing around ownership of the data (the ability to read and write it), they become a powerful and expressive synchronization mechanism.
* '''Go's type system has no hierarchy''', so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical Object Oriented languages.
* '''Garbage Collection is much better'''. In C and C++, programmers spend a lot of time and energy on allocating and freeing memory. The designers of Go wanted to remove that complication, and ensure Go programmers could concentrate on more productive tasks. As such, they implemented garbage collection. As a developer, this is a very good thing. Sure, garbage collection comes with its own set of issues, but those are dealt with by the language implementer while the programmer is free to reap the other many benefits of Go.

=Limitations=
*Go is still an experimental language subject to change.<ref name = "Limitations1">[http://stackoverflow.com/questions/2198529/what-are-the-advantages-and-disadvantages-of-go-programming-language stackoverflow]</ref>
*Go's not very usable on Windows yet.
*The packages distributed with Go are pretty useful, but there are still some libraries you'll miss. Most notably a UI toolkit.
*There is no support for generics in Go, although there are many discussions around it.
*Confusing Semantics Of Exported Identifiers<ref name = "Limitations2">
[https://functionwhatwhat.com/go’s-type-system-is-an-embarrassment functionwhatwhat ]</ref>

=References=

<references />