initial commit

2 files changed, 269 insertions, 0 deletions

diff --git a/files/tr/webassembly/concepts/index.html b/files/tr/webassembly/concepts/index.html
new file mode 100644
index 0000000000..859c82bc59
--- /dev/null
+++ b/files/tr/webassembly/concepts/index.html
@@ -0,0 +1,152 @@
+---
+title: WebAssembly Kavramları
+slug: WebAssembly/Concepts
+translation_of: WebAssembly/Concepts
+---
+<div>{{WebAssemblySidebar}}</div>
+
+<p class="summary">This article explains the concepts behind how WebAssembly works including its goals, the problems it solves, and how it runs inside the web browser's rendering engine.</p>
+
+<h2 id="What_is_WebAssembly">What is WebAssembly?</h2>
+
+<p>WebAssembly is a new type of code that can be run in modern web browsers and provides new features and major gains in performance. It is not primarily intended to be written by hand, rather it is designed to be an effective compilation target for source languages like C, C++, Rust, etc.</p>
+
+<p>This has huge implications for the web platform — it provides a way to run code written in multiple languages on the web at near-native speed, with client apps running on the web that previously couldn’t have done so.</p>
+
+<p>What’s more, you don’t even have to know how to create WebAssembly code to take advantage of it. WebAssembly modules can be imported into a web (or Node.js) app, exposing WebAssembly functions for use via JavaScript. JavaScript frameworks could make use of WebAssembly to confer massive performance advantages and new features while still making functionality easily available to web developers.</p>
+
+<h2 id="WebAssembly_goals">WebAssembly goals</h2>
+
+<p>WebAssembly is being created as an open standard inside the <a href="https://www.w3.org/community/webassembly/">W3C WebAssembly Community Group</a> with the following goals:</p>
+
+<ul>
+ <li>Be fast, efficient, and portable — WebAssembly code can be executed at near-native speed across different platforms by taking advantage of <a href="http://webassembly.org/docs/portability/#assumptions-for-efficient-execution">common hardware capabilities</a>.</li>
+ <li>Be readable and debuggable — WebAssembly is a low-level assembly language, but it does have a human-readable text format (the specification for which is still being finalized) that allows code to be written, viewed, and debugged by hand.</li>
+ <li>Keep secure — WebAssembly is specified to be run in a safe, sandboxed execution environment. Like other web code, it will enforce the browser's same-origin and permissions policies.</li>
+ <li>Don't break the web — WebAssembly is designed so that it plays nicely with other web technologies and maintains backwards compatibility.</li>
+</ul>
+
+<div class="note">
+<p><strong>Note</strong>: WebAssembly will also have uses outside web and JavaScript environments (see <a href="http://webassembly.org/docs/non-web/">Non-web embeddings</a>).</p>
+</div>
+
+<h2 id="How_does_WebAssembly_fit_into_the_web_platform">How does WebAssembly fit into the web platform?</h2>
+
+<p>The web platform can be thought of as having two parts:</p>
+
+<ul>
+ <li>A virtual machine (VM) that runs the Web app’s code, e.g. the JavaScript code that powers your apps.</li>
+ <li>A set of <a href="/en-US/docs/Web/API">Web APIs</a> that the Web app can call to control web browser/device functionality and make things happen (<a href="/en-US/docs/Web/API/Document_Object_Model">DOM</a>, <a href="/en-US/docs/Web/API/CSS_Object_Model">CSSOM</a>, <a href="/en-US/docs/Web/API/WebGL_API">WebGL</a>, <a href="/en-US/docs/Web/API/IndexedDB_API">IndexedDB</a>, <a href="/en-US/docs/Web/API/Web_Audio_API">Web Audio API</a>, etc.).</li>
+</ul>
+
+<p>Historically, the VM has been able to load only JavaScript. This has worked well for us as JavaScript is powerful enough to solve most problems people have on the Web today. We have run into performance problems, however, when trying to use JavaScript for more intensive use cases like 3D games, Virtual and Augmented Reality, computer vision, image/video editing, and a number of other domains that demand native performance (see <a href="http://webassembly.org/docs/use-cases/">WebAssembly use cases</a> for more ideas).</p>
+
+<p>Additionally, the cost of downloading, parsing, and compiling very large JavaScript applications can be prohibitive. Mobile and other resource-constrained platforms can further amplify these performance bottlenecks.</p>
+
+<p>WebAssembly is a different language from JavaScript, but it is not intended as a replacement. Instead, it is designed to complement and work alongside JavaScript, allowing web developers to take advantage of both languages' strong points:</p>
+
+<ul>
+ <li>JavaScript is a high-level language, flexible and expressive enough to write web applications. It has many advantages — it is dynamically typed, requires no compile step, and has a huge ecosystem that provides powerful frameworks, libraries, and other tools.</li>
+ <li>WebAssembly is a low-level assembly-like language with a compact binary format that runs with near-native performance and provides languages with low-level memory models such as C++ and Rust with a compilation target so that they can run on the web. (Note that WebAssembly has the <a href="http://webassembly.org/docs/high-level-goals/">high-level goal</a> of supporting languages with garbage-collected memory models in the future.)</li>
+</ul>
+
+<p>With the advent of WebAssembly appearing in browsers, the virtual machine that we talked about earlier will now load and run two types of code — JavaScript AND WebAssembly.</p>
+
+<p>The different code types can call each other as required — the <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly">WebAssembly JavaScript API</a> wraps exported WebAssembly code with JavaScript functions that can be called normally, and WebAssembly code can import and synchronously call normal JavaScript functions. In fact, the basic unit of WebAssembly code is called a module and WebAssembly modules are symmetric in many ways to ES2015 modules.</p>
+
+<h3 id="WebAssembly_key_concepts">WebAssembly key concepts</h3>
+
+<p>There are several key concepts needed to understand how WebAssembly runs in the browser. All of these concepts are reflected 1:1 in the <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly">WebAssembly JavaScript API</a>.</p>
+
+<ul>
+ <li><strong>Module</strong>: Represents a WebAssembly binary that has been compiled by the browser into executable machine code. A Module is stateless and thus, like a <a href="/en-US/docs/Web/API/Blob">Blob</a>, can be explicitly shared between windows and workers (via <code><a href="/en-US/docs/Web/API/MessagePort/postMessage">postMessage()</a></code>). A Module declares imports and exports just like an ES2015module.</li>
+ <li><strong>Memory</strong>: A resizable ArrayBuffer that contains the linear array of bytes read and written by WebAssembly’s low-level memory access instructions.</li>
+ <li><strong>Table</strong>: A resizable typed array of references (e.g. to functions) that could not otherwise be stored as raw bytes in Memory (for safety and portability reasons).</li>
+ <li><strong>Instance</strong>: A Module paired with all the state it uses at runtime including a Memory, Table, and set of imported values. An Instance is like an ES2015 module that has been loaded into a particular global with a particular set of imports.</li>
+</ul>
+
+<p>The JavaScript API provides developers with the ability to create modules, memories, tables, and instances. Given a WebAssembly instance, JavaScript code can synchronously call its exports, which are exposed as normal JavaScript functions. Arbitrary JavaScript functions can also be synchronously called by WebAssembly code by passing in those JavaScript functions as the imports to a WebAssembly instance.</p>
+
+<p>Since JavaScript has complete control over how WebAssembly code is downloaded, compiled and run, JavaScript developers could even think of WebAssembly as just a JavaScript feature for efficiently generating high-performance functions.</p>
+
+<p>In the future, WebAssembly modules will be <a href="https://github.com/WebAssembly/proposals/issues/12">loadable just like ES2015 modules</a> (using <code>&lt;script type='module'&gt;</code>), meaning that JavaScript will be able to fetch, compile, and import a WebAssembly module as easily as an ES2015 module.</p>
+
+<h2 id="How_do_I_use_WebAssembly_in_my_app">How do I use WebAssembly in my app?</h2>
+
+<p>Above we talked about the raw primitives that WebAssembly adds to the Web platform: a binary format for code and APIs for loading and running this binary code. Now let’s talk about how we can use these primitives in practice.</p>
+
+<p>The WebAssembly ecosystem is at a nascent stage; more tools will undoubtedly emerge going forward. Right now, there are four main entry points:</p>
+
+<ul>
+ <li>Porting a C/C++ application with <a href="/en-US/docs/Mozilla/Projects/Emscripten">Emscripten</a>.</li>
+ <li>Writing or generating WebAssembly directly at the assembly level.</li>
+ <li>Writing a Rust application and targeting WebAssembly as its output.</li>
+ <li>Using <a href="https://assemblyscript.org/">AssemblyScript</a> which looks similar to TypeScript and compiles to WebAssembly binary.</li>
+</ul>
+
+<p>Let’s talk about these options:</p>
+
+<h3 id="Porting_from_CC">Porting from C/C++</h3>
+
+<p>Two of the many options for creating WASM code are an online wasm assembler or <a href="/en-US/docs/Mozilla/Projects/Emscripten">Emscripten</a>. There are a number of online WASM assembler choices, such as:</p>
+
+<ul>
+ <li><a href="https://wasdk.github.io/WasmFiddle/">WasmFiddle</a></li>
+ <li><a href="https://anonyco.github.io/WasmFiddlePlusPlus/">WasmFiddle++</a></li>
+ <li><a href="https://mbebenita.github.io/WasmExplorer/">WasmExplorer</a></li>
+</ul>
+
+<p>These are great resources for people who are trying to figure out where to start, but they lack some of the tooling and optimizations of Emscripten.</p>
+
+<p>The Emscripten tool is able to take just about any C/C++ source code and compile it into a .wasm module, plus the necessary JavaScript "glue" code for loading and running the module, and an HTML document to display the results of the code.</p>
+
+<p><img alt="" src="https://mdn.mozillademos.org/files/14647/emscripten-diagram.png" style="display: block; height: 104px; margin: 0px auto; width: 764px;"></p>
+
+<p>In a nutshell, the process works as follows:</p>
+
+<ol>
+ <li>Emscripten first feeds the C/C++ into clang+LLVM — a mature open-source C/C++ compiler toolchain, shipped as part of XCode on OSX for example.</li>
+ <li>Emscripten transforms the compiled result of clang+LLVM into a .wasm binary.</li>
+ <li>By itself, WebAssembly cannot currently directly access the DOM; it can only call JavaScript, passing in integer and floating point primitive data types. Thus, to access any Web API, WebAssembly needs to call out to JavaScript, which then makes the Web API call. Emscripten therefore creates the HTML and JavaScript glue code needed to achieve this.</li>
+</ol>
+
+<div class="note">
+<p><strong>Note</strong>: There are future plans to <a href="https://github.com/WebAssembly/gc/blob/master/README.md">allow WebAssembly to call Web APIs directly</a>.</p>
+</div>
+
+<p>The JavaScript glue code is not as simple as you might imagine. For a start, Emscripten implements popular C/C++ libraries like <a href="https://en.wikipedia.org/wiki/Simple_DirectMedia_Layer">SDL</a>, <a href="https://en.wikipedia.org/wiki/OpenGL">OpenGL</a>, <a href="https://en.wikipedia.org/wiki/OpenAL">OpenAL</a>, and parts of <a href="https://en.wikipedia.org/wiki/POSIX">POSIX</a>. These libraries are implemented in terms of Web APIs and thus each one requires some JavaScript glue code to connect WebAssembly to the underlying Web API.</p>
+
+<p>So part of the glue code is implementing the functionality of each respective library used by the C/C++ code. The glue code also contains the logic for calling the above-mentioned WebAssembly JavaScript APIs to fetch, load and run the .wasm file.</p>
+
+<p>The generated HTML document loads the JavaScript glue file and writes stdout to a {{htmlelement("textarea")}}. If the application uses OpenGL, the HTML also contains a {{htmlelement("canvas")}} element that is used as the rendering target. It’s very easy to modify the Emscripten output and turn it into whatever web app you require.</p>
+
+<p>You can find full documentation on Emscripten at <a href="https://emscripten.org">emscripten.org</a>, and a guide to implementing the toolchain and compiling your own C/C++ app across to wasm at <a href="https://developer.mozilla.org/en-US/docs/WebAssembly/C_to_wasm">Compiling from C/C++ to WebAssembly</a>.</p>
+
+<h3 id="Writing_WebAssembly_directly">Writing WebAssembly directly</h3>
+
+<p>Do you want to build your own compiler, or your own tools, or make a JavaScript library that generates WebAssembly at runtime?</p>
+
+<p>In the same fashion as physical assembly languages, the WebAssembly binary format has a text representation — the two have a 1:1 correspondence. You can write or generate this format by hand and then convert it into the binary format with any of several <a href="https://webassembly.org/getting-started/advanced-tools/">WebAssemby text-to-binary tools</a>.</p>
+
+<p>For a simple guide on how to do this, see our <a href="/en-US/docs/WebAssembly/Text_format_to_wasm">Converting WebAssembly text format to wasm</a> article.</p>
+
+<h3 id="Writing_Rust_Targeting_WebAssembly">Writing Rust Targeting WebAssembly</h3>
+
+<p>It is also possible to write Rust code and compile over to WebAssembly, thanks to the tireless work of the Rust WebAssembly Working Group. You can get started with installing the necessary toolchain, compiling a sample Rust program to a WebAssembly npm package, and using that in a sample web app, over at our <a href="/en-US/docs/WebAssembly/Rust_to_wasm">Compiling from Rust to WebAssembly</a> article.</p>
+
+<h3 id="Using_AssemblyScript">Using AssemblyScript</h3>
+
+<p>For web developers who want to try WebAssembly without needing to learn the details of C or Rust, AssemblyScript will be the best option. It generates a small bundle and it's performance is slightly slower compared to C or Rust. You can check its documentation on <a href="https://assemblyscript.org/">https://assemblyscript.org/</a>.</p>
+
+<h2 id="Summary">Summary</h2>
+
+<p>This article has given you an explanation of what WebAssembly is, why it is so useful, how it fits into the web, and how you can make use of it.</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li><a href="https://hacks.mozilla.org/category/webassembly/">WebAssembly articles on Mozilla Hacks blog</a></li>
+ <li><a href="https://research.mozilla.org/webassembly/">WebAssembly on Mozilla Research</a></li>
+ <li><a href="/en-US/docs/WebAssembly/Loading_and_running">Loading and running WebAssembly code</a> — find out how to load your own WebAssembly module into a web page.</li>
+ <li><a href="/en-US/docs/WebAssembly/Using_the_JavaScript_API">Using the WebAssembly JavaScript API</a> — find out how to use the other major features of the WebAssembly JavaScript API.</li>
+</ul>
diff --git a/files/tr/webassembly/index.html b/files/tr/webassembly/index.html
new file mode 100644
index 0000000000..0694b4bb44
--- /dev/null
+++ b/files/tr/webassembly/index.html
@@ -0,0 +1,117 @@
+---
+title: WebAssembly
+slug: WebAssembly
+tags:
+  - Landing
+  - WebAssembly
+  - wasm
+translation_of: WebAssembly
+---
+<div>{{WebAssemblySidebar}}</div>
+
+<div>WebAssembly, modern web tarayıcılarda çalıştırılabilen yeni bir kod türüdür — yerel performansa yakın bir performansla çalışan ve C/C++, C# ve Rust gibi dillerle kompakt bir ikili biçime sahip düşük seviyeli bir dildir. Web üzerinde çalışabilmeleri için bir derleme hedefi ile JavaScript ile birlikte çalışabilecek şekilde tasarlanmıştır.</div>
+
+<h2 dir="ltr" id="In_a_Nutshell">In a Nutshell</h2>
+
+<p dir="ltr">WebAssembly has huge implications for the web platform — it provides a way to run code written in multiple languages on the web at near native speed, with client apps running on the web that previously couldn’t have done so.</p>
+
+<p dir="ltr">WebAssembly is designed to complement and run alongside JavaScript — using the WebAssembly JavaScript APIs, you can load WebAssembly modules into a JavaScript app and share functionality between the two. This allows you to take advantage of WebAssembly's performance and power and JavaScript's expressiveness and flexibility in the same apps, even if you don't know how to write WebAssembly code.</p>
+
+<p dir="ltr">And what's even better is that it is being developed as a web standard via the <a href="https://www.w3.org/wasm/">W3C WebAssembly Working Group</a> and <a href="https://www.w3.org/community/webassembly/">Community Group</a> with active participation from all major browser vendors.</p>
+
+<div class="row topicpage-table">
+<div class="section">
+<h2 dir="ltr" id="Guides">Guides</h2>
+
+<dl>
+ <dt><a href="/en-US/docs/WebAssembly/Concepts">WebAssembly concepts</a></dt>
+ <dd>Get started by reading the high-level concepts behind WebAssembly — what it is, why it is so useful, how it fits into the web platform (and beyond), and how to use it.</dd>
+ <dt><a href="/en-US/docs/WebAssembly/C_to_wasm">Compiling a New C/C++ Module to WebAssembly</a></dt>
+ <dd>When you’ve written code in C/C++, you can then compile it into .wasm using a tool like <a href="/en-US/docs/Mozilla/Projects/Emscripten/">Emscripten</a>. Let’s look at how it works.</dd>
+ <dt><a href="/en-US/docs/WebAssembly/existing_C_to_wasm">Compiling an Existing C Module to WebAssembly</a></dt>
+ <dd>A core use-case for WebAssembly is to take the existing ecosystem of C libraries and allow developers to use them on the web.</dd>
+ <dt><a href="/en-US/docs/WebAssembly/rust_to_wasm">Compiling from Rust to WebAssembly</a></dt>
+ <dd>If you've written some Rust code, you can compile it into WebAssembly! This tutorial takes you through all you need to know to compile a Rust project to wasm and use it in an existing web app.</dd>
+ <dt><a href="/en-US/docs/WebAssembly/Loading_and_running">Loading and running WebAssembly code</a></dt>
+ <dd>After you have a .wasm, this article covers how to fetch, compile and instantiate it, combining the <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly">WebAssembly JavaScript</a> API with the <a href="/en-US/docs/Web/API/Fetch_API">Fetch</a> or <a href="/en-US/docs/Web/API/XMLHttpRequest">XHR</a> APIs.</dd>
+ <dt><a href="/en-US/docs/WebAssembly/Using_the_JavaScript_API">Using the WebAssembly JavaScript API</a></dt>
+ <dd>Once you've loaded a .wasm module, you'll want to use it. In this article we show you how to use WebAssembly via the WebAssembly JavaScript API.</dd>
+ <dt><a href="/en-US/docs/WebAssembly/Exported_functions">Exported WebAssembly functions</a></dt>
+ <dd>Exported WebAssembly functions are the JavaScript reflections of WebAssembly functions which allow calling WebAssembly code from JavaScript. This article describes what they are.</dd>
+ <dt><a href="/en-US/docs/WebAssembly/Understanding_the_text_format">Understanding WebAssembly text format</a></dt>
+ <dd>This article explains the wasm text format. This is the low-level textual representation of a .wasm module shown in browser developer tools when debugging.</dd>
+ <dt><a href="/en-US/docs/WebAssembly/Text_format_to_wasm">Converting WebAssembly text format to wasm</a></dt>
+ <dd>This article provides a guide on how to convert a WebAssembly module written in the text format into a .wasm binary.</dd>
+</dl>
+</div>
+
+<div class="section">
+<h2 dir="ltr" id="API_reference">API reference</h2>
+
+<dl>
+ <dt>{{jsxref("Global_objects/WebAssembly", "WebAssembly")}}</dt>
+ <dd>This object acts as the namespace for all WebAssembly related functionality.</dd>
+ <dt>{{jsxref("Global_objects/WebAssembly/Global", "WebAssembly.Global()")}}</dt>
+ <dd>A <code>WebAssembly.Global</code> object represents a global variable instance, accessible from both JavaScript and importable/exportable across one or more {{jsxref("WebAssembly.Module")}} instances. This allows dynamic linking of multiple modules.</dd>
+ <dt>{{jsxref("Global_objects/WebAssembly/Module", "WebAssembly.Module()")}}</dt>
+ <dd>A <code>WebAssembly.Module</code> object contains stateless WebAssembly code that has already been compiled by the browser and can be efficiently <a href="/en-US/docs/Web/API/Worker/postMessage">shared with Workers</a>, and instantiated multiple times.</dd>
+ <dt>{{jsxref("Global_objects/WebAssembly/Instance", "WebAssembly.Instance()")}}</dt>
+ <dd>A <code>WebAssembly.Instance</code> object is a stateful, executable instance of a <code>Module</code>.  <code>Instance</code> objects contain all the <a href="/en-US/docs/WebAssembly/Exported_functions">Exported WebAssembly functions</a> that allow calling into WebAssembly code from JavaScript.</dd>
+ <dt>{{jsxref("Global_objects/WebAssembly/instantiateStreaming", "WebAssembly.instantiateStreaming()")}}</dt>
+ <dd>The <code>WebAssembly.instantiateStreaming()</code> function is the primary API for compiling and instantiating WebAssembly code, returning both a <code>Module</code> and its first <code>Instance</code>.</dd>
+ <dt>{{jsxref("Global_objects/WebAssembly/Memory", "WebAssembly.Memory()")}}</dt>
+ <dd>A <code>WebAssembly.Memory</code> object is a resizable {{jsxref("Global_objects/ArrayBuffer", "ArrayBuffer")}} that holds the raw bytes of memory accessed by an <code>Instance</code>.</dd>
+ <dt>{{jsxref("Global_objects/WebAssembly/Table", "WebAssembly.Table()")}}</dt>
+ <dd>A <code>WebAssembly.Table</code> object is a resizable typed array of opaque values, like function references, that are accessed by an <code>Instance</code>.</dd>
+ <dt>{{jsxref("WebAssembly.CompileError()")}}</dt>
+ <dd>Creates a new WebAssembly <code>CompileError</code> object.</dd>
+ <dt>{{jsxref("WebAssembly.LinkError()")}}</dt>
+ <dd>Creates a new WebAssembly <code>LinkError</code> object.</dd>
+ <dt>{{jsxref("WebAssembly.RuntimeError()")}}</dt>
+ <dd>Creates a new WebAssembly <code>RuntimeError</code> object.</dd>
+</dl>
+</div>
+</div>
+
+<h2 dir="ltr" id="Examples">Examples</h2>
+
+<ul dir="ltr">
+ <li><a href="https://github.com/JasonWeathersby/WASMSobel">WASMSobel</a></li>
+ <li>See our <a href="https://github.com/mdn/webassembly-examples/">webassembly-examples</a> repo for a number of other examples.</li>
+</ul>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('WebAssembly JS')}}</td>
+   <td>{{Spec2('WebAssembly JS')}}</td>
+   <td>Initial draft definition of the JavaScript API.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Browser compatibility</h2>
+
+
+
+<p>{{Compat("javascript.builtins.WebAssembly")}}</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul dir="ltr">
+ <li><a href="https://research.mozilla.org/webassembly/">WebAssembly on Mozilla Research</a></li>
+ <li><a href="http://webassembly.org/">webassembly.org</a></li>
+ <li><a href="https://hacks.mozilla.org/category/webassembly/">WebAssembly articles on Mozilla Hacks blog</a></li>
+ <li><a href="https://www.w3.org/community/webassembly/">W3C WebAssembly Community Group</a></li>
+ <li><a href="/en-US/docs/Web/HTTP/Headers/Large-Allocation">Large-Allocation HTTP header</a></li>
+ <li><a href="https://developers.google.com/web/updates/2018/03/emscripting-a-c-library">Emscripting a C Library to Wasm</a></li>
+</ul>