Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T14:47:06Z

Vboddul: /* Conclusion */

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME<ref>https://mimesniff.spec.whatwg.org/</ref> sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When we do a HTTP web request which declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file or video file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). In this case, we want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received. For example, If its an image we can use image rendering and a video rendering can be used for a video file.

==='''What is Servo?'''===
Servo<ref>https://www.mozilla.org/en-US/research/projects/</ref> is an experimental project to build a Web browser engine for a new generation of hardware: mobile devices, multi-core processors and high-performance GPUs. 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.

Servo builds on top of Rust to provide a secure and reliable foundation. Memory safety at the core of the platform ensures a high degree of assurance in the browser’s trusted computing base. Rust’s lightweight task mechanism also promises to allow fine-grained isolation between browser components, such as tabs and extensions, without the need for expensive runtime protection schemes, like operating system process isolation.

Github link to [https://github.com/servo/servo Servo] Project.

==='''Rust Programming Language'''===
Rust<ref>https://www.mozilla.org/en-US/research/projects/</ref> is a new programming language for developing reliable and efficient systems. It's designed to support concurrency and parallelism in building platforms that take full advantage of modern hardware. Its static type system is safe and expressive and it provides strong guarantees about isolation, concurrency execution and memory safety.

Rust combines powerful and flexible modern programming constructs with a clear performance model to make program efficiency predictable and manageable. One important way it achieves this is by allowing fine-grained control over memory allocation through contiguous records and stack allocation. This control is balanced with the absolute requirement of safety: Rust’s type system and runtime guarantee the absence of data races, buffer overflow, stack overflow or access to uninitialized or deallocated memory.

Github link to [https://github.com/rust-lang/rust Rust language].

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
As part of initial step we first [https://github.com/servo/servo Build Servo]. Learned how to create tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, by creating a sender and receiver pair as well - this task would read all the available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages continued to load unchanged after rebuilding our code.

==='''Classes'''===
As part of OSS Servo project we worked on below Class files.

'''Modify'''
* components/net/resource_task.rs

'''Create'''
* components/net/sniffer_task.rs

'''Delete'''
* none

==='''Step 1'''===
* For every resource request (Example: file, http, data or any kind of request) in load method, it would interpose a sniffer task which sniffs all the data, parse the headers if required and return it. Below is the code snippet of the modified <code> resouce_task.rs </code> file.

<pre>
fn load(&self, load_data: LoadData, start_chan: Sender<LoadResponse>) {
let mut load_data = load_data;
load_data.headers.user_agent = self.user_agent.clone();

// Create new communication channel, create new sniffer task,
// send all the data to the new sniffer task with the send
// end of the pipe, receive all the data.

let sniffer_task = sniffer_task::new_sniffer_task(start_chan.clone());

let loader = match load_data.url.scheme.as_slice() {
"file" => file_loader::factory,
"http" | "https" => http_loader::factory,
"data" => data_loader::factory,
"about" => about_loader::factory,
_ => {
debug!("resource_task: no loader for scheme {:s}", load_data.url.scheme);
start_sending(start_chan, Metadata::default(load_data.url))
.send(Done(Err("no loader for scheme".to_string())));
return
}
};
debug!("resource_task: loading url: {:s}", load_data.url.serialize());

loader(load_data, sniffer_task);
}
</pre>

* The function which gets called in the load method is <code> new_sniffer_task</code>. The sniffer task creates a channel and then call <code> SnifferManager </code> which creates SnifferManager struct with channel information. <code> SnifferManager </code> waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function. Below is the code snippet of the new <code>sniffer_task.rs</code> file.

<pre>
struct SnifferManager {
data_receiver: Receiver<LoadResponse>,
}

impl SnifferManager {
fn new(data_receiver: Receiver <LoadResponse>) -> SnifferManager {
SnifferManager {
data_receiver: data_receiver,
}
}
}

impl SnifferManager {
fn start(&self, next_rx: Sender<LoadResponse>) {
loop {
self.load(next_rx.clone(), self.data_receiver.recv());
}
}

fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
}

</pre>

==Design Patterns==

We used the [http://en.wikipedia.org/wiki/Command_pattern command design pattern] in our project. As Wikipedia states, command pattern is a design pattern that in which an "object is used to represent and encapsulate all the information needed to call a method at a later time". <ref name="commandDesignPatternWiki">http://en.wikipedia.org/wiki/Command_pattern</ref>.

In our specific case, the object is the Sniffer Task. A new Sniffer Task is created via the <code> new_sniffer_task</code> function. When the sniffer task is created, it is isolated and it encapsulates all the information needed to sniff the MIME data out of the URI/file. Since it's isolated, the only way to communicate between the Sniffer Task and the main servo process is by using channels and using <code>send</code> and <code>receive</code> functions to pass data around. For example, in the load function in SnifferManager in <code>sniffer_task.rs</code>, we use <code>send</code> to send the data back to the next processing pipeline.

<pre>
fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
</pre>

There are a few benefits that command design pattern provides. Firstly, since the code block is encapsulated, it is independent and can be modified and switched out easily. This makes maintaining the code very easy. Secondly, because the code blocks has all the resources it needs to perform it's task (in our case, sniffing the MIME), we can easily take it and run it in a different process parallel to the main servo process.

==Sniffer Task Project Build==

* After the code changes we Build servo project by running below command.

<pre> ./mach build </pre>

* Tested the code by passing html webpage request.

<pre>./mach run tests/html/about-mozilla.html </pre>

==Conclusion==
As part of OSS Servo project we have created a new <code>sniffer_task.rs</code> and modified <code>resource_task.rs</code> load method. Then created a merge request [https://github.com/servo/servo/pull/3766 M1456-Implement MIME sniffing initial Step] and got feedback from Josh were we addressed the issues. Few open issues would be addressed as part of Final OSS project.

==Future Development Scope==

==='''Step 2'''===
Move from a 1:1 sniffer:request task model to a shared sniffer task - create the sniffing task in ResourceTask::start, store the created sender in a field, and hand off clones of this sender to the factory function. The sniffer task will now also have to be sent the original sender as well, since it is not available at task creation.

==='''Step 3'''===
When the headers are received, implement the [https://mimesniff.spec.whatwg.org/#handling-a-resource sniffing heuristic algorithm].

==='''Step 4'''===
Implement the mime type matching algorithm, one category at a time - look for a good way to store the patterns and resulting types to minimize code duplication.

==='''Step 5'''===
Ensure that the resulting mime type is present in the load that the consumer receives

==='''Step 6'''===
Write tests that demonstrate working sniffing (for example, loading images with no/wrong extension)

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T14:44:45Z

Vboddul: Added conclusion

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME<ref>https://mimesniff.spec.whatwg.org/</ref> sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When we do a HTTP web request which declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file or video file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). In this case, we want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received. For example, If its an image we can use image rendering and a video rendering can be used for a video file.

==='''What is Servo?'''===
Servo<ref>https://www.mozilla.org/en-US/research/projects/</ref> is an experimental project to build a Web browser engine for a new generation of hardware: mobile devices, multi-core processors and high-performance GPUs. 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.

Servo builds on top of Rust to provide a secure and reliable foundation. Memory safety at the core of the platform ensures a high degree of assurance in the browser’s trusted computing base. Rust’s lightweight task mechanism also promises to allow fine-grained isolation between browser components, such as tabs and extensions, without the need for expensive runtime protection schemes, like operating system process isolation.

Github link to [https://github.com/servo/servo Servo] Project.

==='''Rust Programming Language'''===
Rust<ref>https://www.mozilla.org/en-US/research/projects/</ref> is a new programming language for developing reliable and efficient systems. It's designed to support concurrency and parallelism in building platforms that take full advantage of modern hardware. Its static type system is safe and expressive and it provides strong guarantees about isolation, concurrency execution and memory safety.

Rust combines powerful and flexible modern programming constructs with a clear performance model to make program efficiency predictable and manageable. One important way it achieves this is by allowing fine-grained control over memory allocation through contiguous records and stack allocation. This control is balanced with the absolute requirement of safety: Rust’s type system and runtime guarantee the absence of data races, buffer overflow, stack overflow or access to uninitialized or deallocated memory.

Github link to [https://github.com/rust-lang/rust Rust language].

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
As part of initial step we first [https://github.com/servo/servo Build Servo]. Learned how to create tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, by creating a sender and receiver pair as well - this task would read all the available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages continued to load unchanged after rebuilding our code.

==='''Classes'''===
As part of OSS Servo project we worked on below Class files.

'''Modify'''
* components/net/resource_task.rs

'''Create'''
* components/net/sniffer_task.rs

'''Delete'''
* none

==='''Step 1'''===
* For every resource request (Example: file, http, data or any kind of request) in load method, it would interpose a sniffer task which sniffs all the data, parse the headers if required and return it. Below is the code snippet of the modified <code> resouce_task.rs </code> file.

<pre>
fn load(&self, load_data: LoadData, start_chan: Sender<LoadResponse>) {
let mut load_data = load_data;
load_data.headers.user_agent = self.user_agent.clone();

// Create new communication channel, create new sniffer task,
// send all the data to the new sniffer task with the send
// end of the pipe, receive all the data.

let sniffer_task = sniffer_task::new_sniffer_task(start_chan.clone());

let loader = match load_data.url.scheme.as_slice() {
"file" => file_loader::factory,
"http" | "https" => http_loader::factory,
"data" => data_loader::factory,
"about" => about_loader::factory,
_ => {
debug!("resource_task: no loader for scheme {:s}", load_data.url.scheme);
start_sending(start_chan, Metadata::default(load_data.url))
.send(Done(Err("no loader for scheme".to_string())));
return
}
};
debug!("resource_task: loading url: {:s}", load_data.url.serialize());

loader(load_data, sniffer_task);
}
</pre>

* The function which gets called in the load method is <code> new_sniffer_task</code>. The sniffer task creates a channel and then call <code> SnifferManager </code> which creates SnifferManager struct with channel information. <code> SnifferManager </code> waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function. Below is the code snippet of the new <code>sniffer_task.rs</code> file.

<pre>
struct SnifferManager {
data_receiver: Receiver<LoadResponse>,
}

impl SnifferManager {
fn new(data_receiver: Receiver <LoadResponse>) -> SnifferManager {
SnifferManager {
data_receiver: data_receiver,
}
}
}

impl SnifferManager {
fn start(&self, next_rx: Sender<LoadResponse>) {
loop {
self.load(next_rx.clone(), self.data_receiver.recv());
}
}

fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
}

</pre>

==Design Patterns==

We used the [http://en.wikipedia.org/wiki/Command_pattern command design pattern] in our project. As Wikipedia states, command pattern is a design pattern that in which an "object is used to represent and encapsulate all the information needed to call a method at a later time". <ref name="commandDesignPatternWiki">http://en.wikipedia.org/wiki/Command_pattern</ref>.

In our specific case, the object is the Sniffer Task. A new Sniffer Task is created via the <code> new_sniffer_task</code> function. When the sniffer task is created, it is isolated and it encapsulates all the information needed to sniff the MIME data out of the URI/file. Since it's isolated, the only way to communicate between the Sniffer Task and the main servo process is by using channels and using <code>send</code> and <code>receive</code> functions to pass data around. For example, in the load function in SnifferManager in <code>sniffer_task.rs</code>, we use <code>send</code> to send the data back to the next processing pipeline.

<pre>
fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
</pre>

There are a few benefits that command design pattern provides. Firstly, since the code block is encapsulated, it is independent and can be modified and switched out easily. This makes maintaining the code very easy. Secondly, because the code blocks has all the resources it needs to perform it's task (in our case, sniffing the MIME), we can easily take it and run it in a different process parallel to the main servo process.

==Sniffer Task Project Build==

* After the code changes we Build servo project by running below command.

<pre> ./mach build </pre>

* Tested the code by passing html webpage request.

<pre>./mach run tests/html/about-mozilla.html </pre>

==Conclusion==
As part of OSS Servo project we have created a new <code>sniffer_task.rs</code> and modified <code>resource_task.rs</code> load method. And created a merge request [https://github.com/servo/servo/pull/3766 M1456-Implement MIME sniffing initial Step] and got feedback from Josh.

==Future Development Scope==

==='''Step 2'''===
Move from a 1:1 sniffer:request task model to a shared sniffer task - create the sniffing task in ResourceTask::start, store the created sender in a field, and hand off clones of this sender to the factory function. The sniffer task will now also have to be sent the original sender as well, since it is not available at task creation.

==='''Step 3'''===
When the headers are received, implement the [https://mimesniff.spec.whatwg.org/#handling-a-resource sniffing heuristic algorithm].

==='''Step 4'''===
Implement the mime type matching algorithm, one category at a time - look for a good way to store the patterns and resulting types to minimize code duplication.

==='''Step 5'''===
Ensure that the resulting mime type is present in the load that the consumer receives

==='''Step 6'''===
Write tests that demonstrate working sniffing (for example, loading images with no/wrong extension)

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T14:32:16Z

Vboddul: /* Future Development */

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME<ref>https://mimesniff.spec.whatwg.org/</ref> sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When we do a HTTP web request which declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file or video file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). In this case, we want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received. For example, If its an image we can use image rendering and a video rendering can be used for a video file.

==='''What is Servo?'''===
Servo<ref>https://www.mozilla.org/en-US/research/projects/</ref> is an experimental project to build a Web browser engine for a new generation of hardware: mobile devices, multi-core processors and high-performance GPUs. 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.

Servo builds on top of Rust to provide a secure and reliable foundation. Memory safety at the core of the platform ensures a high degree of assurance in the browser’s trusted computing base. Rust’s lightweight task mechanism also promises to allow fine-grained isolation between browser components, such as tabs and extensions, without the need for expensive runtime protection schemes, like operating system process isolation.

Github link to [https://github.com/servo/servo Servo] Project.

==='''Rust Programming Language'''===
Rust<ref>https://www.mozilla.org/en-US/research/projects/</ref> is a new programming language for developing reliable and efficient systems. It's designed to support concurrency and parallelism in building platforms that take full advantage of modern hardware. Its static type system is safe and expressive and it provides strong guarantees about isolation, concurrency execution and memory safety.

Rust combines powerful and flexible modern programming constructs with a clear performance model to make program efficiency predictable and manageable. One important way it achieves this is by allowing fine-grained control over memory allocation through contiguous records and stack allocation. This control is balanced with the absolute requirement of safety: Rust’s type system and runtime guarantee the absence of data races, buffer overflow, stack overflow or access to uninitialized or deallocated memory.

Github link to [https://github.com/rust-lang/rust Rust language].

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
As part of initial step we first [https://github.com/servo/servo Build Servo]. Learned how to create tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, by creating a sender and receiver pair as well - this task would read all the available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages continued to load unchanged after rebuilding our code.

==='''Classes'''===
As part of OSS Servo project we worked on below Class files.

'''Modify'''
* components/net/resource_task.rs

'''Create'''
* components/net/sniffer_task.rs

'''Delete'''
* none

==='''Step 1'''===
* For every resource request (Example: file, http, data or any kind of request) in load method, it would interpose a sniffer task which sniffs all the data, parse the headers if required and return it. Below is the code snippet of the modified <code> resouce_task.rs </code> file.

<pre>
fn load(&self, load_data: LoadData, start_chan: Sender<LoadResponse>) {
let mut load_data = load_data;
load_data.headers.user_agent = self.user_agent.clone();

// Create new communication channel, create new sniffer task,
// send all the data to the new sniffer task with the send
// end of the pipe, receive all the data.

let sniffer_task = sniffer_task::new_sniffer_task(start_chan.clone());

let loader = match load_data.url.scheme.as_slice() {
"file" => file_loader::factory,
"http" | "https" => http_loader::factory,
"data" => data_loader::factory,
"about" => about_loader::factory,
_ => {
debug!("resource_task: no loader for scheme {:s}", load_data.url.scheme);
start_sending(start_chan, Metadata::default(load_data.url))
.send(Done(Err("no loader for scheme".to_string())));
return
}
};
debug!("resource_task: loading url: {:s}", load_data.url.serialize());

loader(load_data, sniffer_task);
}
</pre>

* The function which gets called in the load method is <code> new_sniffer_task</code>. The sniffer task creates a channel and then call <code> SnifferManager </code> which creates SnifferManager struct with channel information. <code> SnifferManager </code> waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function. Below is the code snippet of the new <code>sniffer_task.rs</code> file.

<pre>
struct SnifferManager {
data_receiver: Receiver<LoadResponse>,
}

impl SnifferManager {
fn new(data_receiver: Receiver <LoadResponse>) -> SnifferManager {
SnifferManager {
data_receiver: data_receiver,
}
}
}

impl SnifferManager {
fn start(&self, next_rx: Sender<LoadResponse>) {
loop {
self.load(next_rx.clone(), self.data_receiver.recv());
}
}

fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
}

</pre>

==Design Patterns==

We used the [http://en.wikipedia.org/wiki/Command_pattern command design pattern] in our project. As Wikipedia states, command pattern is a design pattern that in which an "object is used to represent and encapsulate all the information needed to call a method at a later time". <ref name="commandDesignPatternWiki">http://en.wikipedia.org/wiki/Command_pattern</ref>.

In our specific case, the object is the Sniffer Task. A new Sniffer Task is created via the <code> new_sniffer_task</code> function. When the sniffer task is created, it is isolated and it encapsulates all the information needed to sniff the MIME data out of the URI/file. Since it's isolated, the only way to communicate between the Sniffer Task and the main servo process is by using channels and using <code>send</code> and <code>receive</code> functions to pass data around. For example, in the load function in SnifferManager in <code>sniffer_task.rs</code>, we use <code>send</code> to send the data back to the next processing pipeline.

<pre>
fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
</pre>

There are a few benefits that command design pattern provides. Firstly, since the code block is encapsulated, it is independent and can be modified and switched out easily. This makes maintaining the code very easy. Secondly, because the code blocks has all the resources it needs to perform it's task (in our case, sniffing the MIME), we can easily take it and run it in a different process parallel to the main servo process.

==Sniffer Task Project Build==

* After the code changes we Build servo project by running below command.

<pre> ./mach build </pre>

* Tested the code by passing html webpage request.

<pre>./mach run tests/html/about-mozilla.html </pre>

==Future Development Scope==

==='''Step 2'''===
Move from a 1:1 sniffer:request task model to a shared sniffer task - create the sniffing task in ResourceTask::start, store the created sender in a field, and hand off clones of this sender to the factory function. The sniffer task will now also have to be sent the original sender as well, since it is not available at task creation.

==='''Step 3'''===
When the headers are received, implement the [https://mimesniff.spec.whatwg.org/#handling-a-resource sniffing heuristic algorithm].

==='''Step 4'''===
Implement the mime type matching algorithm, one category at a time - look for a good way to store the patterns and resulting types to minimize code duplication.

==='''Step 5'''===
Ensure that the resulting mime type is present in the load that the consumer receives

==='''Step 6'''===
Write tests that demonstrate working sniffing (for example, loading images with no/wrong extension)

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T14:31:51Z

Vboddul: /* Sniffer Task Project Build */

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME<ref>https://mimesniff.spec.whatwg.org/</ref> sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When we do a HTTP web request which declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file or video file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). In this case, we want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received. For example, If its an image we can use image rendering and a video rendering can be used for a video file.

==='''What is Servo?'''===
Servo<ref>https://www.mozilla.org/en-US/research/projects/</ref> is an experimental project to build a Web browser engine for a new generation of hardware: mobile devices, multi-core processors and high-performance GPUs. 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.

Servo builds on top of Rust to provide a secure and reliable foundation. Memory safety at the core of the platform ensures a high degree of assurance in the browser’s trusted computing base. Rust’s lightweight task mechanism also promises to allow fine-grained isolation between browser components, such as tabs and extensions, without the need for expensive runtime protection schemes, like operating system process isolation.

Github link to [https://github.com/servo/servo Servo] Project.

==='''Rust Programming Language'''===
Rust<ref>https://www.mozilla.org/en-US/research/projects/</ref> is a new programming language for developing reliable and efficient systems. It's designed to support concurrency and parallelism in building platforms that take full advantage of modern hardware. Its static type system is safe and expressive and it provides strong guarantees about isolation, concurrency execution and memory safety.

Rust combines powerful and flexible modern programming constructs with a clear performance model to make program efficiency predictable and manageable. One important way it achieves this is by allowing fine-grained control over memory allocation through contiguous records and stack allocation. This control is balanced with the absolute requirement of safety: Rust’s type system and runtime guarantee the absence of data races, buffer overflow, stack overflow or access to uninitialized or deallocated memory.

Github link to [https://github.com/rust-lang/rust Rust language].

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
As part of initial step we first [https://github.com/servo/servo Build Servo]. Learned how to create tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, by creating a sender and receiver pair as well - this task would read all the available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages continued to load unchanged after rebuilding our code.

==='''Classes'''===
As part of OSS Servo project we worked on below Class files.

'''Modify'''
* components/net/resource_task.rs

'''Create'''
* components/net/sniffer_task.rs

'''Delete'''
* none

==='''Step 1'''===
* For every resource request (Example: file, http, data or any kind of request) in load method, it would interpose a sniffer task which sniffs all the data, parse the headers if required and return it. Below is the code snippet of the modified <code> resouce_task.rs </code> file.

<pre>
fn load(&self, load_data: LoadData, start_chan: Sender<LoadResponse>) {
let mut load_data = load_data;
load_data.headers.user_agent = self.user_agent.clone();

// Create new communication channel, create new sniffer task,
// send all the data to the new sniffer task with the send
// end of the pipe, receive all the data.

let sniffer_task = sniffer_task::new_sniffer_task(start_chan.clone());

let loader = match load_data.url.scheme.as_slice() {
"file" => file_loader::factory,
"http" | "https" => http_loader::factory,
"data" => data_loader::factory,
"about" => about_loader::factory,
_ => {
debug!("resource_task: no loader for scheme {:s}", load_data.url.scheme);
start_sending(start_chan, Metadata::default(load_data.url))
.send(Done(Err("no loader for scheme".to_string())));
return
}
};
debug!("resource_task: loading url: {:s}", load_data.url.serialize());

loader(load_data, sniffer_task);
}
</pre>

* The function which gets called in the load method is <code> new_sniffer_task</code>. The sniffer task creates a channel and then call <code> SnifferManager </code> which creates SnifferManager struct with channel information. <code> SnifferManager </code> waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function. Below is the code snippet of the new <code>sniffer_task.rs</code> file.

<pre>
struct SnifferManager {
data_receiver: Receiver<LoadResponse>,
}

impl SnifferManager {
fn new(data_receiver: Receiver <LoadResponse>) -> SnifferManager {
SnifferManager {
data_receiver: data_receiver,
}
}
}

impl SnifferManager {
fn start(&self, next_rx: Sender<LoadResponse>) {
loop {
self.load(next_rx.clone(), self.data_receiver.recv());
}
}

fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
}

</pre>

==Design Patterns==

We used the [http://en.wikipedia.org/wiki/Command_pattern command design pattern] in our project. As Wikipedia states, command pattern is a design pattern that in which an "object is used to represent and encapsulate all the information needed to call a method at a later time". <ref name="commandDesignPatternWiki">http://en.wikipedia.org/wiki/Command_pattern</ref>.

In our specific case, the object is the Sniffer Task. A new Sniffer Task is created via the <code> new_sniffer_task</code> function. When the sniffer task is created, it is isolated and it encapsulates all the information needed to sniff the MIME data out of the URI/file. Since it's isolated, the only way to communicate between the Sniffer Task and the main servo process is by using channels and using <code>send</code> and <code>receive</code> functions to pass data around. For example, in the load function in SnifferManager in <code>sniffer_task.rs</code>, we use <code>send</code> to send the data back to the next processing pipeline.

<pre>
fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
</pre>

There are a few benefits that command design pattern provides. Firstly, since the code block is encapsulated, it is independent and can be modified and switched out easily. This makes maintaining the code very easy. Secondly, because the code blocks has all the resources it needs to perform it's task (in our case, sniffing the MIME), we can easily take it and run it in a different process parallel to the main servo process.

==Sniffer Task Project Build==

* After the code changes we Build servo project by running below command.

<pre> ./mach build </pre>

* Tested the code by passing html webpage request.

<pre>./mach run tests/html/about-mozilla.html </pre>

==Future Development==

==='''Step 2'''===
Move from a 1:1 sniffer:request task model to a shared sniffer task - create the sniffing task in ResourceTask::start, store the created sender in a field, and hand off clones of this sender to the factory function. The sniffer task will now also have to be sent the original sender as well, since it is not available at task creation.

==='''Step 3'''===
When the headers are received, implement the [https://mimesniff.spec.whatwg.org/#handling-a-resource sniffing heuristic algorithm].

==='''Step 4'''===
Implement the mime type matching algorithm, one category at a time - look for a good way to store the patterns and resulting types to minimize code duplication.

==='''Step 5'''===
Ensure that the resulting mime type is present in the load that the consumer receives

==='''Step 6'''===
Write tests that demonstrate working sniffing (for example, loading images with no/wrong extension)

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T14:31:11Z

Vboddul: /* Sniffer Task Poject Build */

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME<ref>https://mimesniff.spec.whatwg.org/</ref> sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When we do a HTTP web request which declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file or video file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). In this case, we want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received. For example, If its an image we can use image rendering and a video rendering can be used for a video file.

==='''What is Servo?'''===
Servo<ref>https://www.mozilla.org/en-US/research/projects/</ref> is an experimental project to build a Web browser engine for a new generation of hardware: mobile devices, multi-core processors and high-performance GPUs. 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.

Servo builds on top of Rust to provide a secure and reliable foundation. Memory safety at the core of the platform ensures a high degree of assurance in the browser’s trusted computing base. Rust’s lightweight task mechanism also promises to allow fine-grained isolation between browser components, such as tabs and extensions, without the need for expensive runtime protection schemes, like operating system process isolation.

Github link to [https://github.com/servo/servo Servo] Project.

==='''Rust Programming Language'''===
Rust<ref>https://www.mozilla.org/en-US/research/projects/</ref> is a new programming language for developing reliable and efficient systems. It's designed to support concurrency and parallelism in building platforms that take full advantage of modern hardware. Its static type system is safe and expressive and it provides strong guarantees about isolation, concurrency execution and memory safety.

Rust combines powerful and flexible modern programming constructs with a clear performance model to make program efficiency predictable and manageable. One important way it achieves this is by allowing fine-grained control over memory allocation through contiguous records and stack allocation. This control is balanced with the absolute requirement of safety: Rust’s type system and runtime guarantee the absence of data races, buffer overflow, stack overflow or access to uninitialized or deallocated memory.

Github link to [https://github.com/rust-lang/rust Rust language].

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
As part of initial step we first [https://github.com/servo/servo Build Servo]. Learned how to create tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, by creating a sender and receiver pair as well - this task would read all the available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages continued to load unchanged after rebuilding our code.

==='''Classes'''===
As part of OSS Servo project we worked on below Class files.

'''Modify'''
* components/net/resource_task.rs

'''Create'''
* components/net/sniffer_task.rs

'''Delete'''
* none

==='''Step 1'''===
* For every resource request (Example: file, http, data or any kind of request) in load method, it would interpose a sniffer task which sniffs all the data, parse the headers if required and return it. Below is the code snippet of the modified <code> resouce_task.rs </code> file.

<pre>
fn load(&self, load_data: LoadData, start_chan: Sender<LoadResponse>) {
let mut load_data = load_data;
load_data.headers.user_agent = self.user_agent.clone();

// Create new communication channel, create new sniffer task,
// send all the data to the new sniffer task with the send
// end of the pipe, receive all the data.

let sniffer_task = sniffer_task::new_sniffer_task(start_chan.clone());

let loader = match load_data.url.scheme.as_slice() {
"file" => file_loader::factory,
"http" | "https" => http_loader::factory,
"data" => data_loader::factory,
"about" => about_loader::factory,
_ => {
debug!("resource_task: no loader for scheme {:s}", load_data.url.scheme);
start_sending(start_chan, Metadata::default(load_data.url))
.send(Done(Err("no loader for scheme".to_string())));
return
}
};
debug!("resource_task: loading url: {:s}", load_data.url.serialize());

loader(load_data, sniffer_task);
}
</pre>

* The function which gets called in the load method is <code> new_sniffer_task</code>. The sniffer task creates a channel and then call <code> SnifferManager </code> which creates SnifferManager struct with channel information. <code> SnifferManager </code> waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function. Below is the code snippet of the new <code>sniffer_task.rs</code> file.

<pre>
struct SnifferManager {
data_receiver: Receiver<LoadResponse>,
}

impl SnifferManager {
fn new(data_receiver: Receiver <LoadResponse>) -> SnifferManager {
SnifferManager {
data_receiver: data_receiver,
}
}
}

impl SnifferManager {
fn start(&self, next_rx: Sender<LoadResponse>) {
loop {
self.load(next_rx.clone(), self.data_receiver.recv());
}
}

fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
}

</pre>

==Design Patterns==

We used the [http://en.wikipedia.org/wiki/Command_pattern command design pattern] in our project. As Wikipedia states, command pattern is a design pattern that in which an "object is used to represent and encapsulate all the information needed to call a method at a later time". <ref name="commandDesignPatternWiki">http://en.wikipedia.org/wiki/Command_pattern</ref>.

In our specific case, the object is the Sniffer Task. A new Sniffer Task is created via the <code> new_sniffer_task</code> function. When the sniffer task is created, it is isolated and it encapsulates all the information needed to sniff the MIME data out of the URI/file. Since it's isolated, the only way to communicate between the Sniffer Task and the main servo process is by using channels and using <code>send</code> and <code>receive</code> functions to pass data around. For example, in the load function in SnifferManager in <code>sniffer_task.rs</code>, we use <code>send</code> to send the data back to the next processing pipeline.

<pre>
fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
</pre>

There are a few benefits that command design pattern provides. Firstly, since the code block is encapsulated, it is independent and can be modified and switched out easily. This makes maintaining the code very easy. Secondly, because the code blocks has all the resources it needs to perform it's task (in our case, sniffing the MIME), we can easily take it and run it in a different process parallel to the main servo process.

==Sniffer Task Project Build==

* After the code changes we Build servo project by running below command.

<pre> ./mach build </pre>

* Tested the code by passing html webpage.

<pre>./mach run tests/html/about-mozilla.html </pre>

==Future Development==

==='''Step 2'''===
Move from a 1:1 sniffer:request task model to a shared sniffer task - create the sniffing task in ResourceTask::start, store the created sender in a field, and hand off clones of this sender to the factory function. The sniffer task will now also have to be sent the original sender as well, since it is not available at task creation.

==='''Step 3'''===
When the headers are received, implement the [https://mimesniff.spec.whatwg.org/#handling-a-resource sniffing heuristic algorithm].

==='''Step 4'''===
Implement the mime type matching algorithm, one category at a time - look for a good way to store the patterns and resulting types to minimize code duplication.

==='''Step 5'''===
Ensure that the resulting mime type is present in the load that the consumer receives

==='''Step 6'''===
Write tests that demonstrate working sniffing (for example, loading images with no/wrong extension)

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T14:30:50Z

Vboddul: Build servo project

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME<ref>https://mimesniff.spec.whatwg.org/</ref> sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When we do a HTTP web request which declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file or video file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). In this case, we want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received. For example, If its an image we can use image rendering and a video rendering can be used for a video file.

==='''What is Servo?'''===
Servo<ref>https://www.mozilla.org/en-US/research/projects/</ref> is an experimental project to build a Web browser engine for a new generation of hardware: mobile devices, multi-core processors and high-performance GPUs. 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.

Servo builds on top of Rust to provide a secure and reliable foundation. Memory safety at the core of the platform ensures a high degree of assurance in the browser’s trusted computing base. Rust’s lightweight task mechanism also promises to allow fine-grained isolation between browser components, such as tabs and extensions, without the need for expensive runtime protection schemes, like operating system process isolation.

Github link to [https://github.com/servo/servo Servo] Project.

==='''Rust Programming Language'''===
Rust<ref>https://www.mozilla.org/en-US/research/projects/</ref> is a new programming language for developing reliable and efficient systems. It's designed to support concurrency and parallelism in building platforms that take full advantage of modern hardware. Its static type system is safe and expressive and it provides strong guarantees about isolation, concurrency execution and memory safety.

Rust combines powerful and flexible modern programming constructs with a clear performance model to make program efficiency predictable and manageable. One important way it achieves this is by allowing fine-grained control over memory allocation through contiguous records and stack allocation. This control is balanced with the absolute requirement of safety: Rust’s type system and runtime guarantee the absence of data races, buffer overflow, stack overflow or access to uninitialized or deallocated memory.

Github link to [https://github.com/rust-lang/rust Rust language].

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
As part of initial step we first [https://github.com/servo/servo Build Servo]. Learned how to create tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, by creating a sender and receiver pair as well - this task would read all the available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages continued to load unchanged after rebuilding our code.

==='''Classes'''===
As part of OSS Servo project we worked on below Class files.

'''Modify'''
* components/net/resource_task.rs

'''Create'''
* components/net/sniffer_task.rs

'''Delete'''
* none

==='''Step 1'''===
* For every resource request (Example: file, http, data or any kind of request) in load method, it would interpose a sniffer task which sniffs all the data, parse the headers if required and return it. Below is the code snippet of the modified <code> resouce_task.rs </code> file.

<pre>
fn load(&self, load_data: LoadData, start_chan: Sender<LoadResponse>) {
let mut load_data = load_data;
load_data.headers.user_agent = self.user_agent.clone();

// Create new communication channel, create new sniffer task,
// send all the data to the new sniffer task with the send
// end of the pipe, receive all the data.

let sniffer_task = sniffer_task::new_sniffer_task(start_chan.clone());

let loader = match load_data.url.scheme.as_slice() {
"file" => file_loader::factory,
"http" | "https" => http_loader::factory,
"data" => data_loader::factory,
"about" => about_loader::factory,
_ => {
debug!("resource_task: no loader for scheme {:s}", load_data.url.scheme);
start_sending(start_chan, Metadata::default(load_data.url))
.send(Done(Err("no loader for scheme".to_string())));
return
}
};
debug!("resource_task: loading url: {:s}", load_data.url.serialize());

loader(load_data, sniffer_task);
}
</pre>

* The function which gets called in the load method is <code> new_sniffer_task</code>. The sniffer task creates a channel and then call <code> SnifferManager </code> which creates SnifferManager struct with channel information. <code> SnifferManager </code> waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function. Below is the code snippet of the new <code>sniffer_task.rs</code> file.

<pre>
struct SnifferManager {
data_receiver: Receiver<LoadResponse>,
}

impl SnifferManager {
fn new(data_receiver: Receiver <LoadResponse>) -> SnifferManager {
SnifferManager {
data_receiver: data_receiver,
}
}
}

impl SnifferManager {
fn start(&self, next_rx: Sender<LoadResponse>) {
loop {
self.load(next_rx.clone(), self.data_receiver.recv());
}
}

fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
}

</pre>

==Design Patterns==

We used the [http://en.wikipedia.org/wiki/Command_pattern command design pattern] in our project. As Wikipedia states, command pattern is a design pattern that in which an "object is used to represent and encapsulate all the information needed to call a method at a later time". <ref name="commandDesignPatternWiki">http://en.wikipedia.org/wiki/Command_pattern</ref>.

In our specific case, the object is the Sniffer Task. A new Sniffer Task is created via the <code> new_sniffer_task</code> function. When the sniffer task is created, it is isolated and it encapsulates all the information needed to sniff the MIME data out of the URI/file. Since it's isolated, the only way to communicate between the Sniffer Task and the main servo process is by using channels and using <code>send</code> and <code>receive</code> functions to pass data around. For example, in the load function in SnifferManager in <code>sniffer_task.rs</code>, we use <code>send</code> to send the data back to the next processing pipeline.

<pre>
fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
</pre>

There are a few benefits that command design pattern provides. Firstly, since the code block is encapsulated, it is independent and can be modified and switched out easily. This makes maintaining the code very easy. Secondly, because the code blocks has all the resources it needs to perform it's task (in our case, sniffing the MIME), we can easily take it and run it in a different process parallel to the main servo process.

==Sniffer Task Poject Build==

* After the code changes we Build servo project by running below command.

<pre> ./mach build </pre>

* Tested the code by passing html webpage.

<pre>./mach run tests/html/about-mozilla.html </pre>

==Future Development==

==='''Step 2'''===
Move from a 1:1 sniffer:request task model to a shared sniffer task - create the sniffing task in ResourceTask::start, store the created sender in a field, and hand off clones of this sender to the factory function. The sniffer task will now also have to be sent the original sender as well, since it is not available at task creation.

==='''Step 3'''===
When the headers are received, implement the [https://mimesniff.spec.whatwg.org/#handling-a-resource sniffing heuristic algorithm].

==='''Step 4'''===
Implement the mime type matching algorithm, one category at a time - look for a good way to store the patterns and resulting types to minimize code duplication.

==='''Step 5'''===
Ensure that the resulting mime type is present in the load that the consumer receives

==='''Step 6'''===
Write tests that demonstrate working sniffing (for example, loading images with no/wrong extension)

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T14:25:55Z

Vboddul: /* Step 1 */

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME<ref>https://mimesniff.spec.whatwg.org/</ref> sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When we do a HTTP web request which declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file or video file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). In this case, we want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received. For example, If its an image we can use image rendering and a video rendering can be used for a video file.

==='''What is Servo?'''===
Servo<ref>https://www.mozilla.org/en-US/research/projects/</ref> is an experimental project to build a Web browser engine for a new generation of hardware: mobile devices, multi-core processors and high-performance GPUs. 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.

Servo builds on top of Rust to provide a secure and reliable foundation. Memory safety at the core of the platform ensures a high degree of assurance in the browser’s trusted computing base. Rust’s lightweight task mechanism also promises to allow fine-grained isolation between browser components, such as tabs and extensions, without the need for expensive runtime protection schemes, like operating system process isolation.

Github link to [https://github.com/servo/servo Servo] Project.

==='''Rust Programming Language'''===
Rust<ref>https://www.mozilla.org/en-US/research/projects/</ref> is a new programming language for developing reliable and efficient systems. It's designed to support concurrency and parallelism in building platforms that take full advantage of modern hardware. Its static type system is safe and expressive and it provides strong guarantees about isolation, concurrency execution and memory safety.

Rust combines powerful and flexible modern programming constructs with a clear performance model to make program efficiency predictable and manageable. One important way it achieves this is by allowing fine-grained control over memory allocation through contiguous records and stack allocation. This control is balanced with the absolute requirement of safety: Rust’s type system and runtime guarantee the absence of data races, buffer overflow, stack overflow or access to uninitialized or deallocated memory.

Github link to [https://github.com/rust-lang/rust Rust language].

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
As part of initial step we first [https://github.com/servo/servo Build Servo]. Learned how to create tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, by creating a sender and receiver pair as well - this task would read all the available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages continued to load unchanged after rebuilding our code.

==='''Classes'''===
As part of OSS Servo project we worked on below Class files.

'''Modify'''
* components/net/resource_task.rs

'''Create'''
* components/net/sniffer_task.rs

'''Delete'''
* none

==='''Step 1'''===
* For every resource request (Example: file, http, data or any kind of request) in load method, it would interpose a sniffer task which sniffs all the data, parse the headers if required and return it. Below is the code snippet of the modified <code> resouce_task.rs </code> file.

<pre>
fn load(&self, load_data: LoadData, start_chan: Sender<LoadResponse>) {
let mut load_data = load_data;
load_data.headers.user_agent = self.user_agent.clone();

// Create new communication channel, create new sniffer task,
// send all the data to the new sniffer task with the send
// end of the pipe, receive all the data.

let sniffer_task = sniffer_task::new_sniffer_task(start_chan.clone());

let loader = match load_data.url.scheme.as_slice() {
"file" => file_loader::factory,
"http" | "https" => http_loader::factory,
"data" => data_loader::factory,
"about" => about_loader::factory,
_ => {
debug!("resource_task: no loader for scheme {:s}", load_data.url.scheme);
start_sending(start_chan, Metadata::default(load_data.url))
.send(Done(Err("no loader for scheme".to_string())));
return
}
};
debug!("resource_task: loading url: {:s}", load_data.url.serialize());

loader(load_data, sniffer_task);
}
</pre>

* The function which gets called in the load method is <code> new_sniffer_task</code>. The sniffer task creates a channel and then call <code> SnifferManager </code> which creates SnifferManager struct with channel information. <code> SnifferManager </code> waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function. Below is the code snippet of the new <code>sniffer_task.rs</code> file.

<pre>
struct SnifferManager {
data_receiver: Receiver<LoadResponse>,
}

impl SnifferManager {
fn new(data_receiver: Receiver <LoadResponse>) -> SnifferManager {
SnifferManager {
data_receiver: data_receiver,
}
}
}

impl SnifferManager {
fn start(&self, next_rx: Sender<LoadResponse>) {
loop {
self.load(next_rx.clone(), self.data_receiver.recv());
}
}

fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
}

</pre>

==Design Patterns==

We used the [http://en.wikipedia.org/wiki/Command_pattern command design pattern] in our project. As Wikipedia states, command pattern is a design pattern that in which an "object is used to represent and encapsulate all the information needed to call a method at a later time". <ref name="commandDesignPatternWiki">http://en.wikipedia.org/wiki/Command_pattern</ref>.

In our specific case, the object is the Sniffer Task. A new Sniffer Task is created via the <code> new_sniffer_task</code> function. When the sniffer task is created, it is isolated and it encapsulates all the information needed to sniff the MIME data out of the URI/file. Since it's isolated, the only way to communicate between the Sniffer Task and the main servo process is by using channels and using <code>send</code> and <code>receive</code> functions to pass data around. For example, in the load function in SnifferManager in <code>sniffer_task.rs</code>, we use <code>send</code> to send the data back to the next processing pipeline.

<pre>
fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
</pre>

There are a few benefits that command design pattern provides. Firstly, since the code block is encapsulated, it is independent and can be modified and switched out easily. This makes maintaining the code very easy. Secondly, because the code blocks has all the resources it needs to perform it's task (in our case, sniffing the MIME), we can easily take it and run it in a different process parallel to the main servo process.

==Future Development==

==='''Step 2'''===
Move from a 1:1 sniffer:request task model to a shared sniffer task - create the sniffing task in ResourceTask::start, store the created sender in a field, and hand off clones of this sender to the factory function. The sniffer task will now also have to be sent the original sender as well, since it is not available at task creation.

==='''Step 3'''===
When the headers are received, implement the [https://mimesniff.spec.whatwg.org/#handling-a-resource sniffing heuristic algorithm].

==='''Step 4'''===
Implement the mime type matching algorithm, one category at a time - look for a good way to store the patterns and resulting types to minimize code duplication.

==='''Step 5'''===
Ensure that the resulting mime type is present in the load that the consumer receives

==='''Step 6'''===
Write tests that demonstrate working sniffing (for example, loading images with no/wrong extension)

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T14:25:45Z

Vboddul: /* Step 1 */

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME<ref>https://mimesniff.spec.whatwg.org/</ref> sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When we do a HTTP web request which declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file or video file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). In this case, we want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received. For example, If its an image we can use image rendering and a video rendering can be used for a video file.

==='''What is Servo?'''===
Servo<ref>https://www.mozilla.org/en-US/research/projects/</ref> is an experimental project to build a Web browser engine for a new generation of hardware: mobile devices, multi-core processors and high-performance GPUs. 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.

Servo builds on top of Rust to provide a secure and reliable foundation. Memory safety at the core of the platform ensures a high degree of assurance in the browser’s trusted computing base. Rust’s lightweight task mechanism also promises to allow fine-grained isolation between browser components, such as tabs and extensions, without the need for expensive runtime protection schemes, like operating system process isolation.

Github link to [https://github.com/servo/servo Servo] Project.

==='''Rust Programming Language'''===
Rust<ref>https://www.mozilla.org/en-US/research/projects/</ref> is a new programming language for developing reliable and efficient systems. It's designed to support concurrency and parallelism in building platforms that take full advantage of modern hardware. Its static type system is safe and expressive and it provides strong guarantees about isolation, concurrency execution and memory safety.

Rust combines powerful and flexible modern programming constructs with a clear performance model to make program efficiency predictable and manageable. One important way it achieves this is by allowing fine-grained control over memory allocation through contiguous records and stack allocation. This control is balanced with the absolute requirement of safety: Rust’s type system and runtime guarantee the absence of data races, buffer overflow, stack overflow or access to uninitialized or deallocated memory.

Github link to [https://github.com/rust-lang/rust Rust language].

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
As part of initial step we first [https://github.com/servo/servo Build Servo]. Learned how to create tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, by creating a sender and receiver pair as well - this task would read all the available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages continued to load unchanged after rebuilding our code.

==='''Classes'''===
As part of OSS Servo project we worked on below Class files.

'''Modify'''
* components/net/resource_task.rs

'''Create'''
* components/net/sniffer_task.rs

'''Delete'''
* none

==='''Step 1'''===
* For every resource request(Example: file, http, data or any kind of request) in load method, it would interpose a sniffer task which sniffs all the data, parse the headers if required and return it. Below is the code snippet of the modified <code> resouce_task.rs </code> file.

<pre>
fn load(&self, load_data: LoadData, start_chan: Sender<LoadResponse>) {
let mut load_data = load_data;
load_data.headers.user_agent = self.user_agent.clone();

// Create new communication channel, create new sniffer task,
// send all the data to the new sniffer task with the send
// end of the pipe, receive all the data.

let sniffer_task = sniffer_task::new_sniffer_task(start_chan.clone());

let loader = match load_data.url.scheme.as_slice() {
"file" => file_loader::factory,
"http" | "https" => http_loader::factory,
"data" => data_loader::factory,
"about" => about_loader::factory,
_ => {
debug!("resource_task: no loader for scheme {:s}", load_data.url.scheme);
start_sending(start_chan, Metadata::default(load_data.url))
.send(Done(Err("no loader for scheme".to_string())));
return
}
};
debug!("resource_task: loading url: {:s}", load_data.url.serialize());

loader(load_data, sniffer_task);
}
</pre>

* The function which gets called in the load method is <code> new_sniffer_task</code>. The sniffer task creates a channel and then call <code> SnifferManager </code> which creates SnifferManager struct with channel information. <code> SnifferManager </code> waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function. Below is the code snippet of the new <code>sniffer_task.rs</code> file.

<pre>
struct SnifferManager {
data_receiver: Receiver<LoadResponse>,
}

impl SnifferManager {
fn new(data_receiver: Receiver <LoadResponse>) -> SnifferManager {
SnifferManager {
data_receiver: data_receiver,
}
}
}

impl SnifferManager {
fn start(&self, next_rx: Sender<LoadResponse>) {
loop {
self.load(next_rx.clone(), self.data_receiver.recv());
}
}

fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
}

</pre>

==Design Patterns==

We used the [http://en.wikipedia.org/wiki/Command_pattern command design pattern] in our project. As Wikipedia states, command pattern is a design pattern that in which an "object is used to represent and encapsulate all the information needed to call a method at a later time". <ref name="commandDesignPatternWiki">http://en.wikipedia.org/wiki/Command_pattern</ref>.

In our specific case, the object is the Sniffer Task. A new Sniffer Task is created via the <code> new_sniffer_task</code> function. When the sniffer task is created, it is isolated and it encapsulates all the information needed to sniff the MIME data out of the URI/file. Since it's isolated, the only way to communicate between the Sniffer Task and the main servo process is by using channels and using <code>send</code> and <code>receive</code> functions to pass data around. For example, in the load function in SnifferManager in <code>sniffer_task.rs</code>, we use <code>send</code> to send the data back to the next processing pipeline.

<pre>
fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
</pre>

There are a few benefits that command design pattern provides. Firstly, since the code block is encapsulated, it is independent and can be modified and switched out easily. This makes maintaining the code very easy. Secondly, because the code blocks has all the resources it needs to perform it's task (in our case, sniffing the MIME), we can easily take it and run it in a different process parallel to the main servo process.

==Future Development==

==='''Step 2'''===
Move from a 1:1 sniffer:request task model to a shared sniffer task - create the sniffing task in ResourceTask::start, store the created sender in a field, and hand off clones of this sender to the factory function. The sniffer task will now also have to be sent the original sender as well, since it is not available at task creation.

==='''Step 3'''===
When the headers are received, implement the [https://mimesniff.spec.whatwg.org/#handling-a-resource sniffing heuristic algorithm].

==='''Step 4'''===
Implement the mime type matching algorithm, one category at a time - look for a good way to store the patterns and resulting types to minimize code duplication.

==='''Step 5'''===
Ensure that the resulting mime type is present in the load that the consumer receives

==='''Step 6'''===
Write tests that demonstrate working sniffing (for example, loading images with no/wrong extension)

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T14:24:58Z

Vboddul: /* Classes */

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME<ref>https://mimesniff.spec.whatwg.org/</ref> sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When we do a HTTP web request which declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file or video file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). In this case, we want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received. For example, If its an image we can use image rendering and a video rendering can be used for a video file.

==='''What is Servo?'''===
Servo<ref>https://www.mozilla.org/en-US/research/projects/</ref> is an experimental project to build a Web browser engine for a new generation of hardware: mobile devices, multi-core processors and high-performance GPUs. 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.

Servo builds on top of Rust to provide a secure and reliable foundation. Memory safety at the core of the platform ensures a high degree of assurance in the browser’s trusted computing base. Rust’s lightweight task mechanism also promises to allow fine-grained isolation between browser components, such as tabs and extensions, without the need for expensive runtime protection schemes, like operating system process isolation.

Github link to [https://github.com/servo/servo Servo] Project.

==='''Rust Programming Language'''===
Rust<ref>https://www.mozilla.org/en-US/research/projects/</ref> is a new programming language for developing reliable and efficient systems. It's designed to support concurrency and parallelism in building platforms that take full advantage of modern hardware. Its static type system is safe and expressive and it provides strong guarantees about isolation, concurrency execution and memory safety.

Rust combines powerful and flexible modern programming constructs with a clear performance model to make program efficiency predictable and manageable. One important way it achieves this is by allowing fine-grained control over memory allocation through contiguous records and stack allocation. This control is balanced with the absolute requirement of safety: Rust’s type system and runtime guarantee the absence of data races, buffer overflow, stack overflow or access to uninitialized or deallocated memory.

Github link to [https://github.com/rust-lang/rust Rust language].

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
As part of initial step we first [https://github.com/servo/servo Build Servo]. Learned how to create tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, by creating a sender and receiver pair as well - this task would read all the available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages continued to load unchanged after rebuilding our code.

==='''Classes'''===
As part of OSS Servo project we worked on below Class files.

'''Modify'''
* components/net/resource_task.rs

'''Create'''
* components/net/sniffer_task.rs

'''Delete'''
* none

==='''Step 1'''===
* For every resource request(Example: file, http, data or any kind of request) in load method, it would interpose a sniffer task which sniffs all the data, parse the headers if required and return it. Below is the code snippet of the modified resouce_task.rs class file.

<pre>
fn load(&self, load_data: LoadData, start_chan: Sender<LoadResponse>) {
let mut load_data = load_data;
load_data.headers.user_agent = self.user_agent.clone();

// Create new communication channel, create new sniffer task,
// send all the data to the new sniffer task with the send
// end of the pipe, receive all the data.

let sniffer_task = sniffer_task::new_sniffer_task(start_chan.clone());

let loader = match load_data.url.scheme.as_slice() {
"file" => file_loader::factory,
"http" | "https" => http_loader::factory,
"data" => data_loader::factory,
"about" => about_loader::factory,
_ => {
debug!("resource_task: no loader for scheme {:s}", load_data.url.scheme);
start_sending(start_chan, Metadata::default(load_data.url))
.send(Done(Err("no loader for scheme".to_string())));
return
}
};
debug!("resource_task: loading url: {:s}", load_data.url.serialize());

loader(load_data, sniffer_task);
}
</pre>

* The function which gets called in the load method is <code> new_sniffer_task</code>. The sniffer task creates a channel and then call <code> SnifferManager </code> which creates SnifferManager struct with channel information. <code> SnifferManager </code> waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function. Below is the code snippet of the new <code>sniffer_task.rs</code> file.

<pre>
struct SnifferManager {
data_receiver: Receiver<LoadResponse>,
}

impl SnifferManager {
fn new(data_receiver: Receiver <LoadResponse>) -> SnifferManager {
SnifferManager {
data_receiver: data_receiver,
}
}
}

impl SnifferManager {
fn start(&self, next_rx: Sender<LoadResponse>) {
loop {
self.load(next_rx.clone(), self.data_receiver.recv());
}
}

fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
}

</pre>
==Design Patterns==

We used the [http://en.wikipedia.org/wiki/Command_pattern command design pattern] in our project. As Wikipedia states, command pattern is a design pattern that in which an "object is used to represent and encapsulate all the information needed to call a method at a later time". <ref name="commandDesignPatternWiki">http://en.wikipedia.org/wiki/Command_pattern</ref>.

In our specific case, the object is the Sniffer Task. A new Sniffer Task is created via the <code> new_sniffer_task</code> function. When the sniffer task is created, it is isolated and it encapsulates all the information needed to sniff the MIME data out of the URI/file. Since it's isolated, the only way to communicate between the Sniffer Task and the main servo process is by using channels and using <code>send</code> and <code>receive</code> functions to pass data around. For example, in the load function in SnifferManager in <code>sniffer_task.rs</code>, we use <code>send</code> to send the data back to the next processing pipeline.

<pre>
fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
</pre>

There are a few benefits that command design pattern provides. Firstly, since the code block is encapsulated, it is independent and can be modified and switched out easily. This makes maintaining the code very easy. Secondly, because the code blocks has all the resources it needs to perform it's task (in our case, sniffing the MIME), we can easily take it and run it in a different process parallel to the main servo process.

==Future Development==

==='''Step 2'''===
Move from a 1:1 sniffer:request task model to a shared sniffer task - create the sniffing task in ResourceTask::start, store the created sender in a field, and hand off clones of this sender to the factory function. The sniffer task will now also have to be sent the original sender as well, since it is not available at task creation.

==='''Step 3'''===
When the headers are received, implement the [https://mimesniff.spec.whatwg.org/#handling-a-resource sniffing heuristic algorithm].

==='''Step 4'''===
Implement the mime type matching algorithm, one category at a time - look for a good way to store the patterns and resulting types to minimize code duplication.

==='''Step 5'''===
Ensure that the resulting mime type is present in the load that the consumer receives

==='''Step 6'''===
Write tests that demonstrate working sniffing (for example, loading images with no/wrong extension)

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T14:23:47Z

Vboddul: modified Step 1

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME<ref>https://mimesniff.spec.whatwg.org/</ref> sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When we do a HTTP web request which declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file or video file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). In this case, we want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received. For example, If its an image we can use image rendering and a video rendering can be used for a video file.

==='''What is Servo?'''===
Servo<ref>https://www.mozilla.org/en-US/research/projects/</ref> is an experimental project to build a Web browser engine for a new generation of hardware: mobile devices, multi-core processors and high-performance GPUs. 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.

Servo builds on top of Rust to provide a secure and reliable foundation. Memory safety at the core of the platform ensures a high degree of assurance in the browser’s trusted computing base. Rust’s lightweight task mechanism also promises to allow fine-grained isolation between browser components, such as tabs and extensions, without the need for expensive runtime protection schemes, like operating system process isolation.

Github link to [https://github.com/servo/servo Servo] Project.

==='''Rust Programming Language'''===
Rust<ref>https://www.mozilla.org/en-US/research/projects/</ref> is a new programming language for developing reliable and efficient systems. It's designed to support concurrency and parallelism in building platforms that take full advantage of modern hardware. Its static type system is safe and expressive and it provides strong guarantees about isolation, concurrency execution and memory safety.

Rust combines powerful and flexible modern programming constructs with a clear performance model to make program efficiency predictable and manageable. One important way it achieves this is by allowing fine-grained control over memory allocation through contiguous records and stack allocation. This control is balanced with the absolute requirement of safety: Rust’s type system and runtime guarantee the absence of data races, buffer overflow, stack overflow or access to uninitialized or deallocated memory.

Github link to [https://github.com/rust-lang/rust Rust language].

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
As part of initial step we first [https://github.com/servo/servo Build Servo]. Learned how to create tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, by creating a sender and receiver pair as well - this task would read all the available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages continued to load unchanged after rebuilding our code.

==='''Classes'''===
For our code changes we worked on below Class files.
'''Modify'''
* components/net/resource_task.rs

'''Create'''
* components/net/sniffer_task.rs

'''Delete'''
* none

==='''Step 1'''===
* For every resource request(Example: file, http, data or any kind of request) in load method, it would interpose a sniffer task which sniffs all the data, parse the headers if required and return it. Below is the code snippet of the modified resouce_task.rs class file.

<pre>
fn load(&self, load_data: LoadData, start_chan: Sender<LoadResponse>) {
let mut load_data = load_data;
load_data.headers.user_agent = self.user_agent.clone();

// Create new communication channel, create new sniffer task,
// send all the data to the new sniffer task with the send
// end of the pipe, receive all the data.

let sniffer_task = sniffer_task::new_sniffer_task(start_chan.clone());

let loader = match load_data.url.scheme.as_slice() {
"file" => file_loader::factory,
"http" | "https" => http_loader::factory,
"data" => data_loader::factory,
"about" => about_loader::factory,
_ => {
debug!("resource_task: no loader for scheme {:s}", load_data.url.scheme);
start_sending(start_chan, Metadata::default(load_data.url))
.send(Done(Err("no loader for scheme".to_string())));
return
}
};
debug!("resource_task: loading url: {:s}", load_data.url.serialize());

loader(load_data, sniffer_task);
}
</pre>

* The function which gets called in the load method is <code> new_sniffer_task</code>. The sniffer task creates a channel and then call <code> SnifferManager </code> which creates SnifferManager struct with channel information. <code> SnifferManager </code> waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function. Below is the code snippet of the new <code>sniffer_task.rs</code> file.

<pre>
struct SnifferManager {
data_receiver: Receiver<LoadResponse>,
}

impl SnifferManager {
fn new(data_receiver: Receiver <LoadResponse>) -> SnifferManager {
SnifferManager {
data_receiver: data_receiver,
}
}
}

impl SnifferManager {
fn start(&self, next_rx: Sender<LoadResponse>) {
loop {
self.load(next_rx.clone(), self.data_receiver.recv());
}
}

fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
}

</pre>
==Design Patterns==

We used the [http://en.wikipedia.org/wiki/Command_pattern command design pattern] in our project. As Wikipedia states, command pattern is a design pattern that in which an "object is used to represent and encapsulate all the information needed to call a method at a later time". <ref name="commandDesignPatternWiki">http://en.wikipedia.org/wiki/Command_pattern</ref>.

In our specific case, the object is the Sniffer Task. A new Sniffer Task is created via the <code> new_sniffer_task</code> function. When the sniffer task is created, it is isolated and it encapsulates all the information needed to sniff the MIME data out of the URI/file. Since it's isolated, the only way to communicate between the Sniffer Task and the main servo process is by using channels and using <code>send</code> and <code>receive</code> functions to pass data around. For example, in the load function in SnifferManager in <code>sniffer_task.rs</code>, we use <code>send</code> to send the data back to the next processing pipeline.

<pre>
fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
</pre>

There are a few benefits that command design pattern provides. Firstly, since the code block is encapsulated, it is independent and can be modified and switched out easily. This makes maintaining the code very easy. Secondly, because the code blocks has all the resources it needs to perform it's task (in our case, sniffing the MIME), we can easily take it and run it in a different process parallel to the main servo process.

==Future Development==

==='''Step 2'''===
Move from a 1:1 sniffer:request task model to a shared sniffer task - create the sniffing task in ResourceTask::start, store the created sender in a field, and hand off clones of this sender to the factory function. The sniffer task will now also have to be sent the original sender as well, since it is not available at task creation.

==='''Step 3'''===
When the headers are received, implement the [https://mimesniff.spec.whatwg.org/#handling-a-resource sniffing heuristic algorithm].

==='''Step 4'''===
Implement the mime type matching algorithm, one category at a time - look for a good way to store the patterns and resulting types to minimize code duplication.

==='''Step 5'''===
Ensure that the resulting mime type is present in the load that the consumer receives

==='''Step 6'''===
Write tests that demonstrate working sniffing (for example, loading images with no/wrong extension)

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T13:47:59Z

Vboddul: /* Classes */

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME<ref>https://mimesniff.spec.whatwg.org/</ref> sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When we do a HTTP web request which declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file or video file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). In this case, we want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received. For example, If its an image we can use image rendering and a video rendering can be used for a video file.

==='''What is Servo?'''===
Servo<ref>https://www.mozilla.org/en-US/research/projects/</ref> is an experimental project to build a Web browser engine for a new generation of hardware: mobile devices, multi-core processors and high-performance GPUs. 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.

Servo builds on top of Rust to provide a secure and reliable foundation. Memory safety at the core of the platform ensures a high degree of assurance in the browser’s trusted computing base. Rust’s lightweight task mechanism also promises to allow fine-grained isolation between browser components, such as tabs and extensions, without the need for expensive runtime protection schemes, like operating system process isolation.

Github link to [https://github.com/servo/servo Servo] Project.

==='''Rust Programming Language'''===
Rust<ref>https://www.mozilla.org/en-US/research/projects/</ref> is a new programming language for developing reliable and efficient systems. It's designed to support concurrency and parallelism in building platforms that take full advantage of modern hardware. Its static type system is safe and expressive and it provides strong guarantees about isolation, concurrency execution and memory safety.

Rust combines powerful and flexible modern programming constructs with a clear performance model to make program efficiency predictable and manageable. One important way it achieves this is by allowing fine-grained control over memory allocation through contiguous records and stack allocation. This control is balanced with the absolute requirement of safety: Rust’s type system and runtime guarantee the absence of data races, buffer overflow, stack overflow or access to uninitialized or deallocated memory.

Github link to [https://github.com/rust-lang/rust Rust language].

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
As part of initial step we first [https://github.com/servo/servo Build Servo]. Learned how to create tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, by creating a sender and receiver pair as well - this task would read all the available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages continued to load unchanged after rebuilding our code.

==='''Step 1'''===
Interpose a sniffer in every resource request in the load method in resouce_task.rs - make a new sender/receiver pair, spawn a task that waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function.

===='''Classes'''====
'''Modify'''
* components/net/resource_task.rs

'''Create'''
* components/net/sniffer_task.rs

'''Delete'''
* none

==Design Patterns==

We used the [http://en.wikipedia.org/wiki/Command_pattern command design pattern] in our project. As Wikipedia states, command pattern is a design pattern that in which an "object is used to represent and encapsulate all the information needed to call a method at a later time". <ref name="commandDesignPatternWiki">http://en.wikipedia.org/wiki/Command_pattern</ref>.

In our specific case, the object is the Sniffer Task. A new Sniffer Task is created via the <code> new_sniffer_task</code> function. When the sniffer task is created, it is isolated and it encapsulates all the information needed to sniff the MIME data out of the URI/file. Since it's isolated, the only way to communicate between the Sniffer Task and the main servo process is by using channels and using <code>send</code> and <code>receive</code> functions to pass data around. For example, in the load function in SnifferManager in <code>sniffer_task.rs</code>, we use <code>send</code> to send the data back to the next processing pipeline.

<pre>
fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
</pre>

There are a few benefits that command design pattern provides. Firstly, since the code block is encapsulated, it is independent and can be modified and switched out easily. This makes maintaining the code very easy. Secondly, because the code blocks has all the resources it needs to perform it's task (in our case, sniffing the MIME), we can easily take it and run it in a different process parallel to the main servo process.

==Future Development==

==='''Step 2'''===
Move from a 1:1 sniffer:request task model to a shared sniffer task - create the sniffing task in ResourceTask::start, store the created sender in a field, and hand off clones of this sender to the factory function. The sniffer task will now also have to be sent the original sender as well, since it is not available at task creation.

==='''Step 3'''===
When the headers are received, implement the [https://mimesniff.spec.whatwg.org/#handling-a-resource sniffing heuristic algorithm].

==='''Step 4'''===
Implement the mime type matching algorithm, one category at a time - look for a good way to store the patterns and resulting types to minimize code duplication.

==='''Step 5'''===
Ensure that the resulting mime type is present in the load that the consumer receives

==='''Step 6'''===
Write tests that demonstrate working sniffing (for example, loading images with no/wrong extension)

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T13:47:05Z

Vboddul:

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME<ref>https://mimesniff.spec.whatwg.org/</ref> sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When we do a HTTP web request which declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file or video file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). In this case, we want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received. For example, If its an image we can use image rendering and a video rendering can be used for a video file.

==='''What is Servo?'''===
Servo<ref>https://www.mozilla.org/en-US/research/projects/</ref> is an experimental project to build a Web browser engine for a new generation of hardware: mobile devices, multi-core processors and high-performance GPUs. 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.

Servo builds on top of Rust to provide a secure and reliable foundation. Memory safety at the core of the platform ensures a high degree of assurance in the browser’s trusted computing base. Rust’s lightweight task mechanism also promises to allow fine-grained isolation between browser components, such as tabs and extensions, without the need for expensive runtime protection schemes, like operating system process isolation.

Github link to [https://github.com/servo/servo Servo] Project.

==='''Rust Programming Language'''===
Rust<ref>https://www.mozilla.org/en-US/research/projects/</ref> is a new programming language for developing reliable and efficient systems. It's designed to support concurrency and parallelism in building platforms that take full advantage of modern hardware. Its static type system is safe and expressive and it provides strong guarantees about isolation, concurrency execution and memory safety.

Rust combines powerful and flexible modern programming constructs with a clear performance model to make program efficiency predictable and manageable. One important way it achieves this is by allowing fine-grained control over memory allocation through contiguous records and stack allocation. This control is balanced with the absolute requirement of safety: Rust’s type system and runtime guarantee the absence of data races, buffer overflow, stack overflow or access to uninitialized or deallocated memory.

Github link to [https://github.com/rust-lang/rust Rust language].

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
As part of initial step we first [https://github.com/servo/servo Build Servo]. Learned how to create tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, by creating a sender and receiver pair as well - this task would read all the available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages continued to load unchanged after rebuilding our code.

==='''Step 1'''===
Interpose a sniffer in every resource request in the load method in resouce_task.rs - make a new sender/receiver pair, spawn a task that waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function.

===='''Classes'''====
Modify

● components/net/resource_task.rs

Create

● components/net/sniffer_task.rs

Delete

● none

==Design Patterns==

We used the [http://en.wikipedia.org/wiki/Command_pattern command design pattern] in our project. As Wikipedia states, command pattern is a design pattern that in which an "object is used to represent and encapsulate all the information needed to call a method at a later time". <ref name="commandDesignPatternWiki">http://en.wikipedia.org/wiki/Command_pattern</ref>.

In our specific case, the object is the Sniffer Task. A new Sniffer Task is created via the <code> new_sniffer_task</code> function. When the sniffer task is created, it is isolated and it encapsulates all the information needed to sniff the MIME data out of the URI/file. Since it's isolated, the only way to communicate between the Sniffer Task and the main servo process is by using channels and using <code>send</code> and <code>receive</code> functions to pass data around. For example, in the load function in SnifferManager in <code>sniffer_task.rs</code>, we use <code>send</code> to send the data back to the next processing pipeline.

<pre>
fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
</pre>

There are a few benefits that command design pattern provides. Firstly, since the code block is encapsulated, it is independent and can be modified and switched out easily. This makes maintaining the code very easy. Secondly, because the code blocks has all the resources it needs to perform it's task (in our case, sniffing the MIME), we can easily take it and run it in a different process parallel to the main servo process.

==Future Development==

==='''Step 2'''===
Move from a 1:1 sniffer:request task model to a shared sniffer task - create the sniffing task in ResourceTask::start, store the created sender in a field, and hand off clones of this sender to the factory function. The sniffer task will now also have to be sent the original sender as well, since it is not available at task creation.

==='''Step 3'''===
When the headers are received, implement the [https://mimesniff.spec.whatwg.org/#handling-a-resource sniffing heuristic algorithm].

==='''Step 4'''===
Implement the mime type matching algorithm, one category at a time - look for a good way to store the patterns and resulting types to minimize code duplication.

==='''Step 5'''===
Ensure that the resulting mime type is present in the load that the consumer receives

==='''Step 6'''===
Write tests that demonstrate working sniffing (for example, loading images with no/wrong extension)

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T13:42:01Z

Vboddul:

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME<ref>https://mimesniff.spec.whatwg.org/</ref> sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When we do a HTTP web request which declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file or video file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). In this case, we want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received. For example, If its an image we can use image rendering and a video rendering can be used for a video file.

==='''What is Servo?'''===
Servo<ref>https://www.mozilla.org/en-US/research/projects/</ref> is an experimental project to build a Web browser engine for a new generation of hardware: mobile devices, multi-core processors and high-performance GPUs. 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.

Servo builds on top of Rust to provide a secure and reliable foundation. Memory safety at the core of the platform ensures a high degree of assurance in the browser’s trusted computing base. Rust’s lightweight task mechanism also promises to allow fine-grained isolation between browser components, such as tabs and extensions, without the need for expensive runtime protection schemes, like operating system process isolation.

Github link to [https://github.com/servo/servo Servo] Project.

==='''Rust Programming Language'''===
Rust<ref>https://www.mozilla.org/en-US/research/projects/</ref> is a new programming language for developing reliable and efficient systems. It's designed to support concurrency and parallelism in building platforms that take full advantage of modern hardware. Its static type system is safe and expressive and it provides strong guarantees about isolation, concurrency execution and memory safety.

Rust combines powerful and flexible modern programming constructs with a clear performance model to make program efficiency predictable and manageable. One important way it achieves this is by allowing fine-grained control over memory allocation through contiguous records and stack allocation. This control is balanced with the absolute requirement of safety: Rust’s type system and runtime guarantee the absence of data races, buffer overflow, stack overflow or access to uninitialized or deallocated memory.

Github link to [https://github.com/rust-lang/rust Rust language].

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
As part of initial step we first [https://github.com/servo/servo Build Servo]. Learned how to create tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, by creating a sender and receiver pair as well - this task would read all the available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages continued to load unchanged after rebuilding our code.

==='''Step 1'''===
Interpose a sniffer in every resource request in the load method in resouce_task.rs - make a new sender/receiver pair, spawn a task that waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function.

==Design Patterns==

We used the [http://en.wikipedia.org/wiki/Command_pattern command design pattern] in our project. As Wikipedia states, command pattern is a design pattern that in which an "object is used to represent and encapsulate all the information needed to call a method at a later time". <ref name="commandDesignPatternWiki">http://en.wikipedia.org/wiki/Command_pattern</ref>.

In our specific case, the object is the Sniffer Task. A new Sniffer Task is created via the <code> new_sniffer_task</code> function. When the sniffer task is created, it is isolated and it encapsulates all the information needed to sniff the MIME data out of the URI/file. Since it's isolated, the only way to communicate between the Sniffer Task and the main servo process is by using channels and using <code>send</code> and <code>receive</code> functions to pass data around. For example, in the load function in SnifferManager in <code>sniffer_task.rs</code>, we use <code>send</code> to send the data back to the next processing pipeline.

<pre>
fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
</pre>

There are a few benefits that command design pattern provides. Firstly, since the code block is encapsulated, it is independent and can be modified and switched out easily. This makes maintaining the code very easy. Secondly, because the code blocks has all the resources it needs to perform it's task (in our case, sniffing the MIME), we can easily take it and run it in a different process parallel to the main servo process.

==Future Development==

==='''Step 2'''===
Move from a 1:1 sniffer:request task model to a shared sniffer task - create the sniffing task in ResourceTask::start, store the created sender in a field, and hand off clones of this sender to the factory function. The sniffer task will now also have to be sent the original sender as well, since it is not available at task creation.

==='''Step 3'''===
When the headers are received, implement the [https://mimesniff.spec.whatwg.org/#handling-a-resource sniffing heuristic algorithm].

==='''Step 4'''===
Implement the mime type matching algorithm, one category at a time - look for a good way to store the patterns and resulting types to minimize code duplication.

==='''Step 5'''===
Ensure that the resulting mime type is present in the load that the consumer receives

==='''Step 6'''===
Write tests that demonstrate working sniffing (for example, loading images with no/wrong extension)

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T13:40:31Z

Vboddul: modified initial step

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME<ref>https://mimesniff.spec.whatwg.org/</ref> sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When we do a HTTP web request which declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file or video file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). In this case, we want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received. For example, If its an image we can use image rendering and a video rendering can be used for a video file.

==='''What is Servo?'''===
Servo<ref>https://www.mozilla.org/en-US/research/projects/</ref> is an experimental project to build a Web browser engine for a new generation of hardware: mobile devices, multi-core processors and high-performance GPUs. 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.

Servo builds on top of Rust to provide a secure and reliable foundation. Memory safety at the core of the platform ensures a high degree of assurance in the browser’s trusted computing base. Rust’s lightweight task mechanism also promises to allow fine-grained isolation between browser components, such as tabs and extensions, without the need for expensive runtime protection schemes, like operating system process isolation.

Github link to [https://github.com/servo/servo Servo] Project.

==='''Rust Programming Language'''===
Rust<ref>https://www.mozilla.org/en-US/research/projects/</ref> is a new programming language for developing reliable and efficient systems. It's designed to support concurrency and parallelism in building platforms that take full advantage of modern hardware. Its static type system is safe and expressive and it provides strong guarantees about isolation, concurrency execution and memory safety.

Rust combines powerful and flexible modern programming constructs with a clear performance model to make program efficiency predictable and manageable. One important way it achieves this is by allowing fine-grained control over memory allocation through contiguous records and stack allocation. This control is balanced with the absolute requirement of safety: Rust’s type system and runtime guarantee the absence of data races, buffer overflow, stack overflow or access to uninitialized or deallocated memory.

Github link to [https://github.com/rust-lang/rust Rust language].

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
As part of initial step we first Build Servo. Learned how to create tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, by creating a sender and receiver pair as well - this task would read all the available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages continued to load unchanged after rebuilding our code.

==='''Step 1'''===
Interpose a sniffer in every resource request in the load method in resouce_task.rs - make a new sender/receiver pair, spawn a task that waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function.

==Design Patterns==

We used the [http://en.wikipedia.org/wiki/Command_pattern command design pattern] in our project. As Wikipedia states, command pattern is a design pattern that in which an "object is used to represent and encapsulate all the information needed to call a method at a later time". <ref name="commandDesignPatternWiki">http://en.wikipedia.org/wiki/Command_pattern</ref>.

In our specific case, the object is the Sniffer Task. A new Sniffer Task is created via the <code> new_sniffer_task</code> function. When the sniffer task is created, it is isolated and it encapsulates all the information needed to sniff the MIME data out of the URI/file. Since it's isolated, the only way to communicate between the Sniffer Task and the main servo process is by using channels and using <code>send</code> and <code>receive</code> functions to pass data around. For example, in the load function in SnifferManager in <code>sniffer_task.rs</code>, we use <code>send</code> to send the data back to the next processing pipeline.

<pre>
fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
</pre>

There are a few benefits that command design pattern provides. Firstly, since the code block is encapsulated, it is independent and can be modified and switched out easily. This makes maintaining the code very easy. Secondly, because the code blocks has all the resources it needs to perform it's task (in our case, sniffing the MIME), we can easily take it and run it in a different process parallel to the main servo process.

==Future Development==

==='''Step 2'''===
Move from a 1:1 sniffer:request task model to a shared sniffer task - create the sniffing task in ResourceTask::start, store the created sender in a field, and hand off clones of this sender to the factory function. The sniffer task will now also have to be sent the original sender as well, since it is not available at task creation.

==='''Step 3'''===
When the headers are received, implement the [https://mimesniff.spec.whatwg.org/#handling-a-resource sniffing heuristic algorithm].

==='''Step 4'''===
Implement the mime type matching algorithm, one category at a time - look for a good way to store the patterns and resulting types to minimize code duplication.

==='''Step 5'''===
Ensure that the resulting mime type is present in the load that the consumer receives

==='''Step 6'''===
Write tests that demonstrate working sniffing (for example, loading images with no/wrong extension)

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T13:35:05Z

Vboddul: modified background information

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME<ref>https://mimesniff.spec.whatwg.org/</ref> sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When we do a HTTP web request which declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file or video file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). In this case, we want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received. For example, If its an image we can use image rendering and a video rendering can be used for a video file.

==='''What is Servo?'''===
Servo<ref>https://www.mozilla.org/en-US/research/projects/</ref> is an experimental project to build a Web browser engine for a new generation of hardware: mobile devices, multi-core processors and high-performance GPUs. 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.

Servo builds on top of Rust to provide a secure and reliable foundation. Memory safety at the core of the platform ensures a high degree of assurance in the browser’s trusted computing base. Rust’s lightweight task mechanism also promises to allow fine-grained isolation between browser components, such as tabs and extensions, without the need for expensive runtime protection schemes, like operating system process isolation.

Github link to [https://github.com/servo/servo Servo] Project.

==='''Rust Programming Language'''===
Rust<ref>https://www.mozilla.org/en-US/research/projects/</ref> is a new programming language for developing reliable and efficient systems. It's designed to support concurrency and parallelism in building platforms that take full advantage of modern hardware. Its static type system is safe and expressive and it provides strong guarantees about isolation, concurrency execution and memory safety.

Rust combines powerful and flexible modern programming constructs with a clear performance model to make program efficiency predictable and manageable. One important way it achieves this is by allowing fine-grained control over memory allocation through contiguous records and stack allocation. This control is balanced with the absolute requirement of safety: Rust’s type system and runtime guarantee the absence of data races, buffer overflow, stack overflow or access to uninitialized or deallocated memory.

Github link to [https://github.com/rust-lang/rust Rust language].

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
Build Servo. Learn about tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, creating a sender and receiver pair as well - the task should read all available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages should continue to load unchanged after rebuilding.

==='''Step 1'''===
interpose a sniffer in every resource request in the load method in resouce_task.rs - make a new sender/receiver pair, spawn a task that waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function.

==Design Patterns==

We used the [http://en.wikipedia.org/wiki/Command_pattern command design pattern] in our project. As Wikipedia states, command pattern is a design pattern that in which an "object is used to represent and encapsulate all the information needed to call a method at a later time". <ref name="commandDesignPatternWiki">http://en.wikipedia.org/wiki/Command_pattern</ref>.

In our specific case, the object is the Sniffer Task. A new Sniffer Task is created via the <code> new_sniffer_task</code> function. When the sniffer task is created, it is isolated and it encapsulates all the information needed to sniff the MIME data out of the URI/file. Since it's isolated, the only way to communicate between the Sniffer Task and the main servo process is by using channels and using <code>send</code> and <code>receive</code> functions to pass data around. For example, in the load function in SnifferManager in <code>sniffer_task.rs</code>, we use <code>send</code> to send the data back to the next processing pipeline.

<pre>
fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
</pre>

There are a few benefits that command design pattern provides. Firstly, since the code block is encapsulated, it is independent and can be modified and switched out easily. This makes maintaining the code very easy. Secondly, because the code blocks has all the resources it needs to perform it's task (in our case, sniffing the MIME), we can easily take it and run it in a different process parallel to the main servo process.

==Future Development==

==='''Step 2'''===
Move from a 1:1 sniffer:request task model to a shared sniffer task - create the sniffing task in ResourceTask::start, store the created sender in a field, and hand off clones of this sender to the factory function. The sniffer task will now also have to be sent the original sender as well, since it is not available at task creation.

==='''Step 3'''===
When the headers are received, implement the [https://mimesniff.spec.whatwg.org/#handling-a-resource sniffing heuristic algorithm].

==='''Step 4'''===
Implement the mime type matching algorithm, one category at a time - look for a good way to store the patterns and resulting types to minimize code duplication.

==='''Step 5'''===
Ensure that the resulting mime type is present in the load that the consumer receives

==='''Step 6'''===
Write tests that demonstrate working sniffing (for example, loading images with no/wrong extension)

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T01:19:20Z

Vboddul:

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T01:12:44Z

Vboddul:

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T01:04:41Z

Vboddul: /* Implement MIME sniffing - spec */

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T00:57:07Z

Vboddul:

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T00:54:47Z

Vboddul:

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When an HTTP resource declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). We want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received.

==='''What is Servo?'''===

==='''Rust'''===

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
Build Servo. Learn about tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, creating a sender and receiver pair as well - the task should read all available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages should continue to load unchanged after rebuilding.

==='''Step 1'''===
interpose a sniffer in every resource request in the load method in resouce_task.rs - make a new sender/receiver pair, spawn a task that waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function.

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T00:54:05Z

Vboddul: /* Implement MIME sniffing - spec */

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in Rust<ref>http://doc.rust-lang.org/guide.html</ref> language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When an HTTP resource declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). We want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received.

==='''What is Servo?'''===

==='''Rust'''===

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
Build Servo. Learn about tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, creating a sender and receiver pair as well - the task should read all available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages should continue to load unchanged after rebuilding.

==='''Step 1'''===
interpose a sniffer in every resource request in the load method in resouce_task.rs - make a new sender/receiver pair, spawn a task that waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function.

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-27T22:39:22Z

Vboddul: /* Setting up Servo */

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When an HTTP resource declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). We want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received.

==='''What is Servo?'''===

==='''Rust'''===

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
Build Servo. Learn about tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, creating a sender and receiver pair as well - the task should read all available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages should continue to load unchanged after rebuilding.

==='''Step 1'''===
interpose a sniffer in every resource request in the load method in resouce_task.rs - make a new sender/receiver pair, spawn a task that waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function.

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-27T22:39:01Z

Vboddul:

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When an HTTP resource declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). We want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received.

==='''What is Servo?'''===

==='''Rust'''===

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
Build Servo. Learn about tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, creating a sender and receiver pair as well - the task should read all available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages should continue to load unchanged after rebuilding.

==='''Step 1'''===
interpose a sniffer in every resource request in the load method in resouce_task.rs - make a new sender/receiver pair, spawn a task that waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function.

=='''Appendix'''==
===''Setting up Servo''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-27T22:38:21Z

Vboddul: /* What is Servo? */

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When an HTTP resource declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). We want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received.

===''What is Servo?''===

===''Rust''===

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
Build Servo. Learn about tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, creating a sender and receiver pair as well - the task should read all available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages should continue to load unchanged after rebuilding.

==='''Step 1'''===
interpose a sniffer in every resource request in the load method in resouce_task.rs - make a new sender/receiver pair, spawn a task that waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function.

=='''Appendix'''==
===''Setting up Servo''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-27T22:37:56Z

Vboddul: /* Implement MIME sniffing - spec */

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When an HTTP resource declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). We want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received.

===''What is Servo?''===

===''Rust''===

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
Build Servo. Learn about tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, creating a sender and receiver pair as well - the task should read all available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages should continue to load unchanged after rebuilding.

==='''Step 1'''===
interpose a sniffer in every resource request in the load method in resouce_task.rs - make a new sender/receiver pair, spawn a task that waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function.

=='''Appendix'''==
===''Setting up Servo''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-27T22:36:56Z

Vboddul: /* Implement MIME sniffing - spec */

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Here you can find a brief Background information about MIME sniffing in servo project, rust programming language, the initial step and the first step implemented in this particular project.

__TOC__

== '''Background Information''' ==
When an HTTP resource declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). We want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received.

===''What is Servo?''===

===''Rust''===

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
Build Servo. Learn about tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, creating a sender and receiver pair as well - the task should read all available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages should continue to load unchanged after rebuilding.

==='''Step 1'''===
interpose a sniffer in every resource request in the load method in resouce_task.rs - make a new sender/receiver pair, spawn a task that waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function.

=='''Appendix'''==
===''Setting up Servo''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-27T22:35:06Z

Vboddul: /* Implement MIME sniffing - spec */

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is a part of the ongoing development of the Servo Parallel Browser Project. Here you can find a brief Background information about MIME sniffing in servo project, rust programming language, the initial step and the first step implemented in this particular project.

__TOC__

== '''Background Information''' ==
When an HTTP resource declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). We want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received.

===''What is Servo?''===

===''Rust''===

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
Build Servo. Learn about tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, creating a sender and receiver pair as well - the task should read all available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages should continue to load unchanged after rebuilding.

==='''Step 1'''===
interpose a sniffer in every resource request in the load method in resouce_task.rs - make a new sender/receiver pair, spawn a task that waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function.

=='''Appendix'''==
===''Setting up Servo''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-27T22:08:39Z

Vboddul: /* Implement MIME sniffing - spec */

='''Implement MIME sniffing - spec'''=

This article is about the project [https://github.com/servo/servo/issues/3144 M 1456: Implement MIME sniffing - spec], which is a part of the ongoing development on the Servo browser. Here you can find a brief description about the servo project, rust programming language, requirements of this particular project, setting up of the development environment and other relevant details.

__TOC__

== '''Introduction''' ==
==='' What is Servo?''===

=='''Implement MIME sniffing'''==

=='''Appendix'''==
===''Setting up Servo''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-27T22:07:11Z

Vboddul: /* Implement MIME sniffing - spec */

='''Implement MIME sniffing - spec'''=

This article is about the project M 1456: Implement MIME sniffing - spec<ref> https://github.com/servo/servo/issues/3144 </ref>, which is a part of the ongoing development on the Servo browser. Here you can find a brief description about the servo project, rust programming language, requirements of this particular project, setting up of the development environment and other relevant details.

__TOC__

== '''Introduction''' ==
==='' What is Servo?''===

=='''Implement MIME sniffing'''==

=='''Appendix'''==
===''Setting up Servo''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-26T14:26:00Z

Vboddul: /* Setting up Servo */

='''Implement MIME sniffing - spec'''=

This article is about the project M 1456: Implement MIME sniffing - spec, which is a part of the ongoing development on the Servo browser. Here you can find a brief description about the servo project, rust programming language, requirements of this particular project, setting up of the development environment and other relevant details.

__TOC__

== '''Introduction''' ==
==='' What is Servo?''===

=='''Implement MIME sniffing'''==

=='''Appendix'''==
===''Setting up Servo''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-26T14:24:33Z

Vboddul: Created Wiki page and added page structure

='''Implement MIME sniffing - spec'''=

This article is about the project M 1456: Implement MIME sniffing - spec, which is a part of the ongoing development on the Servo browser. Here you can find a brief description about the servo project, rust programming language, requirements of this particular project, setting up of the development environment and other relevant details.

__TOC__

== '''Introduction''' ==
==='' What is Servo?''===

=='''Implement MIME sniffing'''==

=='''Appendix'''==
===''Setting up Servo''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/mozilla/servo Build Servo] <ref> https://github.com/mozilla/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014

2014-10-26T14:18:32Z

Vboddul:

*[[CSC/ECE_517_Fall_2014/sample_page]]
*[[CSC/ECE_517_Fall_2014/ch1a 22 as]]
*[[CSC/ECE 517 Fall 2014/ch1a 19 mx]]
*[[CSC/ECE 517 Fall 2014/ch1a 3 zq]]
*[[CSC/ECE 517 Fall 2014/ch1a 4 lf]]
*[[CSC/ECE 517 Fall 2014/ch1a 4 wl]]
*[[CSC/ECE 517 Fall 2014/ch1a a7 ch]]
*[[CSC/ECE 517 Fall 2014/ch1a 25 rs]]
*[[CSC/ECE 517 Fall 2014/ch1a 25 jf]]
*[[CSC/ECE 517 Fall 2014/ch1a 8 os]]
*[[CSC/ECE 517 Fall 2014/ch1a 8 sn]]
*[[CSC/ECE 517 Fall 2014/ch1a 15 gs]]
*[[CSC/ECE 517 Fall 2014/ch1a 10 hu]]
*[[CSC/ECE 517 Fall 2014/ch1a 20 kv]]
*[[CSC/ECE 517 Fall 2014/ch1a 21 as]]
*[[CSC/ECE 517 Fall 2014/ch1a 24 sa]]
*[[CSC/ECE 517 Fall 2014/ch1a 26 sn]]
*[[CSC/ECE 517 Fall 2014/ch1a 6 rl]]
*[[CSC/ECE 517 Fall 2014/ch1a 2 ss]]
*[[CSC/ECE 517 Fall 2014/ch1a 16 av]]
*[[CSC/ECE 517 Fall 2014/ch1a 1 rm]]
*[[CSC/ECE 517 Fall 2014/ch1a 1 sj]]
*[[CSC/ECE 517 Fall 2014/ch1a 23 ss]]
*[[CSC/ECE 517 Fall 2014/ch1a 20 rn]]
*[[CSC/ECE 517 Fall 2014/ch1a 22 sp]]
*[[CSC/ECE 517 Fall 2014/ch1a 26 gn]]

*[[CSC/ECE 517 Fall 2014/ch1a 13 va]]
*[[CSC/ECE 517 Fall 2014/ch1a 9 aa]]
*[[CSC/ECE 517 Fall 2014/ch1a 9 kn]]
*[[CSC/ECE 517 Fall 2014/ch1a 11 ap]]
*[[CSC/ECE 517 Fall 2014/ch1a 25 ks]]
*[[CSC/ECE 517 Fall 2014/ch1a 7 kz]]
*[[CSC/ECE_517_Fall_2014/ch1a_6_bn]]
*[[CSC/ECE_517_Fall_2014/ch1a 10 zz]]
*[[CSC/ECE_517_Fall_2014/ch1a 16 va]]
*[[CSC/ECE_517_Fall_2014/ch1a F1415 rv]]
*[[CSC/ECE_517_Fall_2014/ch1a_3_cp]]
*[[CSC/ECE 517 Fall 2014/ch1b 26 sa]]
*[[CSC/ECE_517_Fall_2014/ch1b_28_cg]]
*[[CSC/ECE_517_Fall_2014/ch1b 29 ry]]
*[[CSC/ECE_517_Fall_2014/ch1b 30 cs]]
*[[CSC/ECE_517_Fall_2014/ch1b_33_jy]]
*[[CSC/ECE_517_Fall_2014/ch1b_27_js]]
*[[CSC/ECE 517 Fall 2014/oss E1465 oak]]
*[[CSC/ECE 517 Fall 2014/oss_M1456_kdv]]

CSC/ECE 517 Fall 2014

2014-10-26T14:17:54Z

Vboddul: Added Wiki Link for OSS - M 1456: Implement MIME sniffing - spec

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-26T03:20:42Z

Vboddul: /* Comparison of Swift with Objective-C */

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)]<ref>[http://en.wikipedia.org/wiki/Swift_(programming_language) Swift]</ref>, giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work on Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift<ref>[https://developer.apple.com/swift/ Introduction to Swift]</ref> is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If the code runs over time, for instance through a loop, its progress can be seen in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images<ref>[http://www.sitepoint.com/introduction-swift-programming-language/ More about Playground]</ref>

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop)<ref>[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground REPL]</ref> is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator<ref>[https://www.youtube.com/watch?v=F9T551Y0mYo Timeline]</ref>:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Comparison of Swift with Objective-C=

A comparison of Xcode Objective-C and Xcode6 with Swift <ref>[http://blog.shinetech.com/2014/07/22/swift-from-an-objective-c-developers-perspective/ Swift and Objective C]</ref>
*In Swift unlike Objective-C, type annotations are not required. The Swift compiler infers the data type and as a result the code size is reduced.
*Objective-C provides dynamic runtime, however, in Swift, the compiler checks all the types when a method is called; instead of dynamic invocation. This enables to find more errors and at the same time increases the speed.
*Unlike Objective-C, Swift uses closures instead of blocks to pass functions. Closures are easy to write and read.
* Instead of using “nil” as in Objective-C, “optionals” are introduces in Swift to handle absence of a value. In Objective-C only objects can be nil but in Swift any value can be set to nil.
*Swift introduces generics that were not present in Objective-C. With generics, a placeholder can be used first and its specific type can be defined later.

In summary, Swift combines the advantages of Objective-C and modern scripting languages. It is faster than Objective-C. It has clean code and powerful debugging tools.

=Comparison of Swift with Python=

Apple’s developers used Python as a benchmark against Swift and Objective-C. A lot of discussion is on-going about the comparison between Python and Swift. This comparison is possibly because of the ease of development and readability that Swift provides. This expressiveness in Swift is similar to Python. At the same time Swift is compiled and is much faster. While a lot of people are excited about the ease of programming and the performance that Swift provides, there are others who think that Swift still has a long way to go before it can be compared with something as powerful as Python.

=Release History=
{| class="wikitable" style="font-size: 100%; text-align: center; width: auto;"

|-
! Date
! Release Notes

|-
| 6/2/2014
| Swift Launched

|-
| 9/9/2014
| Swift version 1.0 is now GM

|}

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
<references/>

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-26T03:19:38Z

Vboddul:

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)]<ref>[http://en.wikipedia.org/wiki/Swift_(programming_language) Swift]</ref>, giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work on Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift<ref>[https://developer.apple.com/swift/ Introduction to Swift]</ref> is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If the code runs over time, for instance through a loop, its progress can be seen in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images<ref>[http://www.sitepoint.com/introduction-swift-programming-language/ More about Playground]</ref>

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop)<ref>[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground REPL]</ref> is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator<ref>[https://www.youtube.com/watch?v=F9T551Y0mYo Timeline]</ref>:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Comparison of Swift with Objective-C=

A comparison of Xcode Objective-C and Xcode6 with Swift <ref>[http://blog.shinetech.com/2014/07/22/swift-from-an-objective-c-developers-perspective/]</ref>
*In Swift unlike Objective-C, type annotations are not required. The Swift compiler infers the data type and as a result the code size is reduced.
*Objective-C provides dynamic runtime, however, in Swift, the compiler checks all the types when a method is called; instead of dynamic invocation. This enables to find more errors and at the same time increases the speed.
*Unlike Objective-C, Swift uses closures instead of blocks to pass functions. Closures are easy to write and read.
* Instead of using “nil” as in Objective-C, “optionals” are introduces in Swift to handle absence of a value. In Objective-C only objects can be nil but in Swift any value can be set to nil.
*Swift introduces generics that were not present in Objective-C. With generics, a placeholder can be used first and its specific type can be defined later.

In summary, Swift combines the advantages of Objective-C and modern scripting languages. It is faster than Objective-C. It has clean code and powerful debugging tools.

=Comparison of Swift with Python=

Apple’s developers used Python as a benchmark against Swift and Objective-C. A lot of discussion is on-going about the comparison between Python and Swift. This comparison is possibly because of the ease of development and readability that Swift provides. This expressiveness in Swift is similar to Python. At the same time Swift is compiled and is much faster. While a lot of people are excited about the ease of programming and the performance that Swift provides, there are others who think that Swift still has a long way to go before it can be compared with something as powerful as Python.

=Release History=
{| class="wikitable" style="font-size: 100%; text-align: center; width: auto;"

|-
! Date
! Release Notes

|-
| 6/2/2014
| Swift Launched

|-
| 9/9/2014
| Swift version 1.0 is now GM

|}

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
<references/>

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-26T02:36:35Z

Vboddul:

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)]<ref>[http://en.wikipedia.org/wiki/Swift_(programming_language) Swift]</ref>, giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work on Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift<ref>[https://developer.apple.com/swift/ Introduction to Swift]</ref> is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If the code runs over time, for instance through a loop, its progress can be seen in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images<ref>[http://www.sitepoint.com/introduction-swift-programming-language/ More about Playground]</ref>

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop)<ref>[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground REPL]</ref> is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator<ref>[https://www.youtube.com/watch?v=F9T551Y0mYo Timeline]</ref>:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Comparison of Swift with Python=

Apple’s developers used Python as a benchmark against Swift and Objective-C. A lot of discussion is on-going about the comparison between Python and Swift. This comparison is possibly because of the ease of development and readability that Swift provides. This expressiveness in Swift is similar to Python. At the same time Swift is compiled and is much faster. While a lot of people are excited about the ease of programming and the performance that Swift provides, there are others who think that Swift still has a long way to go before it can be compared with something as powerful as Python.

=Release History=
{| class="wikitable" style="font-size: 100%; text-align: center; width: auto;"

|-
! Date
! Release Notes

|-
| 6/2/2014
| Swift Launched

|-
| 9/9/2014
| Swift version 1.0 is now GM

|}

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
<references/>

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-26T01:59:13Z

Vboddul: /* Release History */

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)], giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work in Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift<ref>[https://developer.apple.com/swift/ Introduction to Swift]</ref> is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If your code runs over time, for instance through a loop, you can watch its progress in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images<ref>[http://www.sitepoint.com/introduction-swift-programming-language/ More about Playground]</ref>

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop)<ref>[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground REPL]</ref> is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, you can click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator<ref>[https://www.youtube.com/watch?v=F9T551Y0mYo Timeline]</ref>:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Release History=
{| class="wikitable" style="font-size: 100%; text-align: center; width: auto;"

|-
! Date
! Release Notes

|-
| 6/2/2014
| Swift Launched

|-
| 9/9/2014
| Swift version 1.0 is now GM

|}

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
<references/>

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-26T01:58:23Z

Vboddul: /* Release History */

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)], giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work in Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift<ref>[https://developer.apple.com/swift/ Introduction to Swift]</ref> is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If your code runs over time, for instance through a loop, you can watch its progress in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images<ref>[http://www.sitepoint.com/introduction-swift-programming-language/ More about Playground]</ref>

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop)<ref>[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground REPL]</ref> is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, you can click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator<ref>[https://www.youtube.com/watch?v=F9T551Y0mYo Timeline]</ref>:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Release History=
{| class="wikitable" style="font-size: 100%; text-align: center; width: auto;"

|-
! Date
! Release Notes

|-
| 6/2/2014
| Swift Launched

|-
| 9/9/2014
| Swift 1.0

|}

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
<references/>

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-26T01:57:54Z

Vboddul:

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)], giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work in Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift<ref>[https://developer.apple.com/swift/ Introduction to Swift]</ref> is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If your code runs over time, for instance through a loop, you can watch its progress in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images<ref>[http://www.sitepoint.com/introduction-swift-programming-language/ More about Playground]</ref>

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop)<ref>[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground REPL]</ref> is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, you can click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator<ref>[https://www.youtube.com/watch?v=F9T551Y0mYo Timeline]</ref>:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Release History=
* On September 9th 2014, Apple published in their developer's blog that 'Swift Has Reached 1.0'.
* On September 15th 2014, Apple announced Xcode 6.1 beta 2.<ref>[https://developer.apple.com/news/ Apple Developer News and Updates]</ref>
{| class="wikitable" style="font-size: 80%; text-align: center; width: auto;"

|-
! Date
! Release Notes

|-
| 6/2/2014
| Swift Launched

|-
| 9/9/2014
| Swift 1.0

|}

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
<references/>

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-20T03:19:05Z

Vboddul: /* Playgrounds with Swift in XCode v6.0 */

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)], giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work in Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift<ref>[https://developer.apple.com/swift/ Introduction to Swift]</ref> is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If your code runs over time, for instance through a loop, you can watch its progress in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images<ref>[http://www.sitepoint.com/introduction-swift-programming-language/ More about Playground]</ref>

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop)<ref>[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground REPL]</ref> is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, you can click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator<ref>[https://www.youtube.com/watch?v=F9T551Y0mYo Timeline]</ref>:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Recent Updates=
* On September 9th 2014, Apple published in their developer's blog that 'Swift Has Reached 1.0'.
* On September 15th 2014, Apple announced Xcode 6.1 beta 2.<ref>[https://developer.apple.com/news/ Apple Developer News and Updates]</ref>

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
<references/>

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-20T03:18:40Z

Vboddul: /* Playgrounds with Swift in XCode v6.0 */

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
Playgrounds with Swift in XCode
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)], giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work in Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift<ref>[https://developer.apple.com/swift/ Introduction to Swift]</ref> is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If your code runs over time, for instance through a loop, you can watch its progress in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images<ref>[http://www.sitepoint.com/introduction-swift-programming-language/ More about Playground]</ref>

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop)<ref>[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground REPL]</ref> is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, you can click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator<ref>[https://www.youtube.com/watch?v=F9T551Y0mYo Timeline]</ref>:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Recent Updates=
* On September 9th 2014, Apple published in their developer's blog that 'Swift Has Reached 1.0'.
* On September 15th 2014, Apple announced Xcode 6.1 beta 2.<ref>[https://developer.apple.com/news/ Apple Developer News and Updates]</ref>

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
<references/>

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-20T03:16:53Z

Vboddul: /* References */

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)], giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work in Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift<ref>[https://developer.apple.com/swift/ Introduction to Swift]</ref> is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If your code runs over time, for instance through a loop, you can watch its progress in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images<ref>[http://www.sitepoint.com/introduction-swift-programming-language/ More about Playground]</ref>

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop)<ref>[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground REPL]</ref> is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, you can click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator<ref>[https://www.youtube.com/watch?v=F9T551Y0mYo Timeline]</ref>:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Recent Updates=
* On September 9th 2014, Apple published in their developer's blog that 'Swift Has Reached 1.0'.
* On September 15th 2014, Apple announced Xcode 6.1 beta 2.<ref>[https://developer.apple.com/news/ Apple Developer News and Updates]</ref>

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
<references/>

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-20T03:16:36Z

Vboddul: /* More About Playgrounds */

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)], giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work in Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift<ref>[https://developer.apple.com/swift/ Introduction to Swift]</ref> is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If your code runs over time, for instance through a loop, you can watch its progress in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images<ref>[http://www.sitepoint.com/introduction-swift-programming-language/ More about Playground]</ref>

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop)<ref>[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground REPL]</ref> is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, you can click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator<ref>[https://www.youtube.com/watch?v=F9T551Y0mYo Timeline]</ref>:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Recent Updates=
* On September 9th 2014, Apple published in their developer's blog that 'Swift Has Reached 1.0'.
* On September 15th 2014, Apple announced Xcode 6.1 beta 2.<ref>[https://developer.apple.com/news/ Apple Developer News and Updates]</ref>

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
* http://www.sitepoint.com/introduction-swift-programming-language/
<references/>

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-20T03:15:19Z

Vboddul: /* References */

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)], giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work in Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift<ref>[https://developer.apple.com/swift/ Introduction to Swift]</ref> is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If your code runs over time, for instance through a loop, you can watch its progress in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images.

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop)<ref>[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground REPL]</ref> is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, you can click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator<ref>[https://www.youtube.com/watch?v=F9T551Y0mYo Timeline]</ref>:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Recent Updates=
* On September 9th 2014, Apple published in their developer's blog that 'Swift Has Reached 1.0'.
* On September 15th 2014, Apple announced Xcode 6.1 beta 2.<ref>[https://developer.apple.com/news/ Apple Developer News and Updates]</ref>

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
* http://www.sitepoint.com/introduction-swift-programming-language/
<references/>

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-20T03:13:20Z

Vboddul: /* Timeline */

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)], giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work in Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift<ref>[https://developer.apple.com/swift/ Introduction to Swift]</ref> is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If your code runs over time, for instance through a loop, you can watch its progress in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images.

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop)<ref>[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground REPL]</ref> is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, you can click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator<ref>[https://www.youtube.com/watch?v=F9T551Y0mYo Timeline]</ref>:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Recent Updates=
* On September 9th 2014, Apple published in their developer's blog that 'Swift Has Reached 1.0'.
* On September 15th 2014, Apple announced Xcode 6.1 beta 2.<ref>[https://developer.apple.com/news/ Apple Developer News and Updates]</ref>

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
* https://www.youtube.com/watch?v=F9T551Y0mYo 
* http://www.youtube.com/watch?v=sp8-jf20HNA 
* https://www.youtube.com/watch?v=xtZl1_zc3gg 
* http://blog.teamtreehouse.com/an-absolute-beginners-guide-to-swift 
* http://www.sitepoint.com/introduction-swift-programming-language/
<references/>

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-20T03:12:03Z

Vboddul: /* References */

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)], giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work in Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift<ref>[https://developer.apple.com/swift/ Introduction to Swift]</ref> is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If your code runs over time, for instance through a loop, you can watch its progress in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images.

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop)<ref>[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground REPL]</ref> is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, you can click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Recent Updates=
* On September 9th 2014, Apple published in their developer's blog that 'Swift Has Reached 1.0'.
* On September 15th 2014, Apple announced Xcode 6.1 beta 2.<ref>[https://developer.apple.com/news/ Apple Developer News and Updates]</ref>

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
* https://www.youtube.com/watch?v=F9T551Y0mYo 
* http://www.youtube.com/watch?v=sp8-jf20HNA 
* https://www.youtube.com/watch?v=xtZl1_zc3gg 
* http://blog.teamtreehouse.com/an-absolute-beginners-guide-to-swift 
* http://www.sitepoint.com/introduction-swift-programming-language/
<references/>

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-20T03:11:41Z

Vboddul: /* Swift */

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)], giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work in Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift<ref>[https://developer.apple.com/swift/ Introduction to Swift]</ref> is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If your code runs over time, for instance through a loop, you can watch its progress in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images.

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop)<ref>[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground REPL]</ref> is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, you can click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Recent Updates=
* On September 9th 2014, Apple published in their developer's blog that 'Swift Has Reached 1.0'.
* On September 15th 2014, Apple announced Xcode 6.1 beta 2.<ref>[https://developer.apple.com/news/ Apple Developer News and Updates]</ref>

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
* https://developer.apple.com/swift/ 
* https://www.youtube.com/watch?v=A0C6L4XmrZM 
* https://www.youtube.com/watch?v=F9T551Y0mYo 
* http://www.youtube.com/watch?v=sp8-jf20HNA 
* https://www.youtube.com/watch?v=xtZl1_zc3gg 
* http://blog.teamtreehouse.com/an-absolute-beginners-guide-to-swift 
* http://www.sitepoint.com/introduction-swift-programming-language/
<references/>

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-20T03:10:33Z

Vboddul: /* References */

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)], giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work in Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If your code runs over time, for instance through a loop, you can watch its progress in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images.

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop)<ref>[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground REPL]</ref> is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, you can click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Recent Updates=
* On September 9th 2014, Apple published in their developer's blog that 'Swift Has Reached 1.0'.
* On September 15th 2014, Apple announced Xcode 6.1 beta 2.<ref>[https://developer.apple.com/news/ Apple Developer News and Updates]</ref>

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
* https://developer.apple.com/swift/ 
* https://www.youtube.com/watch?v=A0C6L4XmrZM 
* https://www.youtube.com/watch?v=F9T551Y0mYo 
* http://www.youtube.com/watch?v=sp8-jf20HNA 
* https://www.youtube.com/watch?v=xtZl1_zc3gg 
* http://blog.teamtreehouse.com/an-absolute-beginners-guide-to-swift 
* http://www.sitepoint.com/introduction-swift-programming-language/
<references/>

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-20T03:10:12Z

Vboddul: /* Read-Eval-Print-Loop (REPL) */

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)], giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work in Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If your code runs over time, for instance through a loop, you can watch its progress in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images.

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop)<ref>[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground REPL]</ref> is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, you can click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Recent Updates=
* On September 9th 2014, Apple published in their developer's blog that 'Swift Has Reached 1.0'.
* On September 15th 2014, Apple announced Xcode 6.1 beta 2.<ref>[https://developer.apple.com/news/ Apple Developer News and Updates]</ref>

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
* http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground 
* http://rshankar.com/xcode-6-and-playground/ 
* https://developer.apple.com/swift/ 
* https://www.youtube.com/watch?v=A0C6L4XmrZM 
* https://www.youtube.com/watch?v=F9T551Y0mYo 
* http://www.youtube.com/watch?v=sp8-jf20HNA 
* https://www.youtube.com/watch?v=xtZl1_zc3gg 
* http://blog.teamtreehouse.com/an-absolute-beginners-guide-to-swift 
* http://www.sitepoint.com/introduction-swift-programming-language/
<references/>

CSC/ECE 517 Fall 2014/ch1a 13 va

2014-09-20T03:09:00Z

Vboddul: /* Limitations of Playground */

== '''Playgrounds with Swift in XCode v6.0''' ==
<div style="float: right; border:1px solid grey;">
[[File:swift-xcode.jpg]]
[[File:playgrounds.png|center|Fig 1: Playgrounds with Swift in Xcode v6.0 ]]
</div>
On June 2, 2014 at the [http://en.wikipedia.org/wiki/Apple_Worldwide_Developers_Conference World Wide Developers Conference], Apple announced version 6 of Xcode. Features include Playgrounds live debugging tools, as well as an entirely new programming language called Swift. A key element of the Swift system is its ability to be cleanly debugged and run within the development environment, using a [http://en.wikipedia.org/wiki/Read–eval–print_loop read–eval–print loop (REPL)], giving it interactive properties more in common with scripting systems like Python than traditional systems programming languages. The REPL is further enhanced with the new 'playgrounds' concept; 'playgrounds' are interactive views running within the Xcode environment that respond to code or debugger changes on-the-fly. If the code in question changes over time or with regard to some other ranged input value, the view can be used with the Timeline Assistant to demonstrate the output in an animated fashion.

Apple claims that Swift "is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language."<ref name="Topic">[https://docs.google.com/a/ncsu.edu/document/d/1eq3XHiUUBIrEBx-R2Mgolaw7HttSgzPniwDLEF5oVk0/edit# Topic Document]</ref>
 

__TOC__

=Background=

===Xcode===
Xcode is an [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated Development Environment] (IDE) developed by Apple for developing software for iOS and OS X. The Xcode suite consists of the IDE, Apple’s developer documentation and a built-in interface builder. It is shipped free with Mac OS X 10.3, but is able to develop OS X applications that can run on any version of OS X. It extends and replaces Apple's earlier tool, Project Builder, which was inherited from [http://en.wikipedia.org/wiki/NeXT NeXT]. However, Xcode officially does not work in Mac OS X 10.2.It works hand in hand with Interface Builder (also inherited from NeXT), a graphical tool used to create user interfaces.

Xcode includes GCC, and can compile [http://en.wikipedia.org/wiki/C C], [http://en.wikipedia.org/wiki/C%2B%2B C++], Objective C++, [http://en.wikipedia.org/wiki/java Java], and [http://en.wikipedia.org/wiki/Objective-C Objective C] source code with a variety of programming models, including but not limited to [http://en.wikipedia.org/wiki/Cocoa_(API) Cocoa], Carbon, and Java.
The latest Xcode version 6 includes Playgrounds which has an interactive sidebar to display the results of the code on-the-fly.

===Swift===
Swift is a new programming language that adopts safe programming patterns and makes programming flexible. Swift combines the best of both C and Objective-C. It integrates both - the procedural features like types and operators as well as the object-oriented features such as classes and protocols. It adopts readability and dynamic object model from Objective-C and has added new features like blocks, collection literals and modules, fast performance. Swift has many advantages over Objective-C, like being more type-safe, having more natural and concise syntax, no need for header/implementation files. It has simplified memory management with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting Automatic Reference Counting]. Swift is a fast and powerful programming language that is easier and more fun to implement.

=Playgrounds=
Playgrounds<ref>[http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start Playgrounds]</ref> enable the interactive experience of a script language, even though Swift compiles to highly-optimized native code. Type a line of code and the result appears immediately. If your code runs over time, for instance through a loop, you can watch its progress in the Timeline assistant. The Timeline displays variables in a graph, draws each step when composing a view, and can play an animated SpriteKit scene.

===Getting Started with Playgrounds===
On opening Xcode6, select "Get started with a Playground". Default is a Hello Playgrounds program.<ref>[https://www.youtube.com/watch?v=A0C6L4XmrZM Introduction to Swift Playground]</ref>
[[File: pgstart.png|frame|center]]

Playgrounds with Swift introduce user friendly, clean code. Writing code in poetry-method has become simpler with Swift. Inclusion of packages is not necessary and heavy syntax can be ignored.
Creation of class is not required while writing code in Swift. Writing "str" in Swift would display the value of "str" on Playground directly.
Semicolons are not required at the end of each line. Datatype can be stated in the code, but it is not required as Swift implicitly assigns the datatype.

[[File:swiftpic3.png|frame|center]]

If the datatype of a variable is explicitly stated, the variable cannot be assigned a value that does not belong to its datatype. Such an assignment results in an error. Swift introduces a new keyword "let" for declaring constants. If the value of a constant declared with "let" is changed, an error is displayed.
While iterating through a loop in Swift, the value of the iterator is shown on the console on-the-fly.

==More About Playgrounds==
Playgrounds files are used for testing and prototyping code. The results in the sidebar are displayed in black but during the modification of the code, the results temporarily change to gray during processing. ImageView can be used to display images.

[[File: codesnippet.jpg|frame|center]]

===Read-Eval-Print-Loop (REPL)===
REPL (Read Evaluate Print Loop) is an interactive version of Swift. It is a procedure that loops in following iterations: 
''Read'': Read is called and characters in user input are read. 
''Eval(uate)'': The input is then evaluated and returned 
''Print'': The evaluated result in printed in a textual representation for the users 
REPL in Swift enables the user to evaluate and interact with his code in a script-like environment.

===Viewing Result===
To view graphical display of results, like images or strings, you can click on the Quick Look ([[File:quicklook.png|quicklook.png]] ) button. Access to Quick Look buttons can be gained by moving the pointer along the right edge of the sidebar.<ref>[https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/ExploringandEvaluatingSwiftCodeinaPlayground.html View Results in Playground]</ref>

[[File:swift.jpg|frame|center]]

Assistant Editor button can be used to examine values that change throughout the execution of the code. 
i. Interim value of a code like for loop can be viewed through Value History button ([[File:history.png]]) 
ii. Live view item can be used to view the drawing results. Live view item draws itself in response to the code.

===Timeline===
The progress of results can be seen on the timeline. The time limit can also be set for the timeline to play back values. An item can be collapsed or expanded by clicking on the expression at the top of the item. An item can be removed from the timeline by clicking on the close button on the upper left corner of the item. The timeline can be closed by clicking on the close button on the Assistant Editor jump bar. It can be opened by clicking on the Assistant Editor button in the workspace toolbar or by clicking any Value History button.
The value of iterator in a loop can be seen by viewing the timeline. The timeline can display different types of items depending on the input. The value of iterator is shown as graph where the x-axis represents the execution time in seconds and the y-axis represents different values for the iterator. The graph changes on changing the value of the iterator:

[[File:assistantpic5.png|frame|center]]

===Error===
The error messages in Playground is shown as a ! icon. The details about the error can be viewed by clicking on this icon. The image below shows the error message that will be displayed if a variable declared as a string is assigned an integer value.

[[File:swiftpic5.png|frame|center]]

===Limitations of Playground<ref>[http://rshankar.com/xcode-6-and-playground/ Limitations of Playground]</ref>===
i Playgrounds should not be used for performance testing as logging of results will dominate the runtime. 
ii Playground does not support On-device execution. 
iii Does not support custom entitlements. 
iv Playgrounds can not be used for things that require user-interactions

===Issues in Beta Playground===

i. There are some flaws in beta release which can harm the system of user, like erasing hard drive.

ii. It was reported by 9to5Mac that a developer discovered that the application is not sandboxed, i.e., Swift code entered in a playground has access to the entire computer sytem. The realtime nature of Playgrounds means that you don't even have to press ENTER to start the erasing process!<ref name= "issues in beta playground">[http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground Issues in beta Playground]</ref>

=Recent Updates=
* On September 9th 2014, Apple published in their developer's blog that 'Swift Has Reached 1.0'.
* On September 15th 2014, Apple announced Xcode 6.1 beta 2.<ref>[https://developer.apple.com/news/ Apple Developer News and Updates]</ref>

=See Also=
* http://en.wikipedia.org/wiki/Xcode
* http://en.wikipedia.org/wiki/Swift_(programming_language)

=References=
* http://swiftlanguagetutorials.com/apple-swift-language-code-menu/apple-swift-language-faq/205-swift-language-faq-what-is-an-xcode-playground 
* http://rshankar.com/xcode-6-and-playground/ 
* https://developer.apple.com/swift/ 
* https://www.youtube.com/watch?v=A0C6L4XmrZM 
* https://www.youtube.com/watch?v=F9T551Y0mYo 
* http://www.youtube.com/watch?v=sp8-jf20HNA 
* https://www.youtube.com/watch?v=xtZl1_zc3gg 
* http://blog.teamtreehouse.com/an-absolute-beginners-guide-to-swift 
* http://www.sitepoint.com/introduction-swift-programming-language/
<references/>