commit

Author: DevScholar

src/benchmarking/index.md

@@ -5,8 +5,8 @@ command for `cargo` which is executing all the methods annotated with the
 `#[bench]` attribute. This attribute is currently [unstable][bench-unstable] and
 available only for the nightly channel.
 
-.NET users can make use of `BenchmarkDotNet` library to benchmark methods and
-track their performance. The equivalent of `BenchmarkDotNet` is a crate named
+.NET users can make use of `Benchmark.js` library to benchmark methods and
+track their performance. The equivalent of `Benchmark.js` is a crate named
 `Criterion`.
 
 As per its [documentation][criterion-docs], `Criterion` collects and stores
@@ -16,8 +16,8 @@ regressions as well as measuring optimizations.
 Using `Criterion` is possible to use the `#[bench]` attribute without moving to
 the nightly channel.
 
-As in `BenchmarkDotNet`, it is also possible to integrate benchmark results with
-the [GitHub Action for Continuous Benchmarking][gh-action-bench]. `Criterion`,
+<!--As in `BenchmarkDotNet`, it is also possible to integrate benchmark results with
+the [GitHub Action for Continuous Benchmarking][gh-action-bench]. -->`Criterion`,
 in fact, supports multiple output formats, amongst which there is also the
 `bencher` format, mimicking the nightly `libtest` benchmarks and compatible with
 the above mentioned action.

src/conditional-compilation/index.md

@@ -1,17 +1,17 @@
 # Conditional Compilation
 
-Both .NET and Rust are providing the possibility for compiling specific code
+Both JavaScript and Rust are providing the possibility for compiling specific code
 based on external conditions.
 
-In .NET it is possible to use the some [preprocessor directives][preproc-dir] in
-order to control conditional compilation
+JavaScript doesn't support conditional compilation natively. However, it is possible to use some third-party tool like [`babel-plugin-preprocessor`][preproc-dir] in
+order to control conditional compilation. 
 
-```csharp
-#if debug
+```js
+//#if DEBUG
     Console.WriteLine("Debug");
-#else
+//#else
     Console.WriteLine("Not debug");
-#endif
+//#endif
 ```
 
 In addition to predefined symbols, it is also possible to use the compiler
@@ -22,9 +22,6 @@ In Rust it is possible to use the [`cfg attribute`][cfg],
 the [`cfg_attr attribute`][cfg-attr] or the
 [`cfg macro`][cfg-macro] to control conditional compilation
 
-As per .NET, in addition to predefined symbols, it is also possible to use the
-[compiler flag `--cfg`][cfg-flag] to arbitrarily set configuration options
-
 The [`cfg attribute`][cfg] is requiring and evaluating a
 `ConfigurationPredicate`
 
@@ -110,5 +107,5 @@ See also:
 [cfg-flag]: https://doc.rust-lang.org/rustc/command-line-arguments.html#--cfg-configure-the-compilation-environment
 [cfg-attr]: https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute
 [cfg-macro]: https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-macro
-[preproc-dir]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/preprocessor-directives#conditional-compilation
-[DefineConstants]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-options/language#defineconstants
+[preproc-dir]: https://github.com/kaysonwu/babel-plugin-preprocessor
+[DefineConstants]: https://github.com/kaysonwu/babel-plugin-preprocessor?tab=readme-ov-file#usage

src/environment-and-configuration/index.md

@@ -2,9 +2,32 @@
 
 ## Accessing environment variables
 
-.NET provides access to environment variables via the
-`System.Environment.GetEnvironmentVariable` method. This method retrieves the
-value of an environment variable at runtime.
+JavaScript doesn't provide access to environment variables natively. However, some non-browser JavaScript runtimes, such as Node.js and Node provides access to environment variables.
+
+In Node.js:
+
+```js
+const name = "EXAMPLE_VARIABLE";
+
+let value = process.env[name];
+if (!value) {
+    console.log(`Variable '${name}' not set.`);
+} else {
+    console.log(`Variable '${name}' set to '${value}'.`);
+}
+```
+In Deno:
+
+```js
+const name = "EXAMPLE_VARIABLE";
+
+let value = Deno.env.get(name);
+if (!value) {
+    console.log(`Variable '${name}' not set.`);
+} else {
+    console.log(`Variable '${name}' set to '${value}'.`);
+}
+```
 
 ```csharp
 using System;
@@ -68,14 +91,10 @@ fn main() {
 }
 ```
 
-In .NET a compile time access to environment variables can be achieved, in a
-less straightforward way, via [source generators][source-gen].
-
-[source-gen]: https://learn.microsoft.com/en-us/dotnet/csharp/roslyn-sdk/source-generators-overview
-
 ## Configuration
 
-Configuration in .NET is possible with configuration providers. The framework is
+JavaScript doesn't support configurations.
+<!--Configuration in .NET is possible with configuration providers. The framework is
 providing several provider implementations via
 `Microsoft.Extensions.Configuration` namespace and NuGet packages.
 
@@ -105,7 +124,9 @@ Other providers examples can be found in the official documentation
 
 A similar configuration experience in Rust is available via use of third-party
 crates such as [figment] or [config].
-
+-->
+In Rust it is available via use of third-party
+crates such as [figment] or [config].
 See the following example making use of [config] crate:
 
 ```rust

src/language/scalar-types.md

@@ -5,7 +5,7 @@ JavaScript:
 
 | Rust    | JavaScript                | Note        |
 | ------- | ------------------------- | ----------- |
-| `bool`  | `boolean`                    |             |
+| `bool`  | `boolean`                 |             |
 | `char`  | `string`                  | See note 1. |
 | `i8`    | `number`                  | See note 2. |
 | `i16`   | `number`                  |             |

src/logging-and-tracing/index.md

@@ -1,16 +1,13 @@
 # Logging and Tracing
 
-.NET supports a number of logging APIs. For most cases, `ILogger` is a good
-default choice, since it works with a variety of built-in and third-party
-logging providers. In C#, a minimal example for structured logging could look
+For most cases, `console.log()` is a good
+default choice for JavaScript, since it works with a variety of built-in and third-party
+logging providers. In JavaScript, a minimal example for structured logging could look
 like:
 
-```csharp
-using Microsoft.Extensions.Logging;
-
-using var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
-var logger = loggerFactory.CreateLogger<Program>();
-logger.LogInformation("Hello {Day}.", "Thursday"); // Hello Thursday.
+```js
+let day = "Thursday";
+console.log("Hello ", day); // Hello Thursday.
 ```
 
 In Rust, a lightweight logging facade is provided by [log][log.rs]. It has less

src/testing/index.md

@@ -2,9 +2,9 @@
 
 ## Test organization
 
-.NET solutions use separate projects to host test code, irrespective of the
-test framework being used (xUnit, NUnit, MSTest, etc.) and the type of tests
-(unit or integration) being wirtten. The test code therefore lives in a
+JavaScript solutions use separate projects to host test code, irrespective of the
+test framework being used (Jest, Mocha, etc.) and the type of tests
+(unit or integration) being written. The test code therefore lives in a
 separate assembly than the application or library code being tested. In Rust,
 it is a lot more conventional for _unit tests_ to be found in a separate test
 sub-module (conventionally) named `tests`, but which is placed in same _source
@@ -14,7 +14,7 @@ tests. This has two benefits:
 - The code/module and its unit tests live side-by-side.
 
 - There is no need for a workaround like `[InternalsVisibleTo]` that exists in
-  .NET because the tests have access to internals by virtual of being a
+  JavaScript because the tests have access to internals by virtual of being a
   sub-module.
 
 The test sub-module is annotated with the `#[cfg(test)]` attribute, which has
@@ -67,17 +67,23 @@ For more information, see "[Showing Function Output][test-output]".
   [test-output]: https://doc.rust-lang.org/book/ch11-02-running-tests.html#showing-function-output
 
 ## Assertions
+JavaScript users have multiple ways to assert, depending on the framework being used. For example, an assertion Jest might look like:
+```js
+test('something has the right length', () => {
+    let value = "something";
+    expect(value.length).toBe(9);
+});
+```
 
-.NET users have multiple ways to assert, depending on the framework being
-used. For example, an assertion xUnit.net might look like:
+An example that only uses vanilla JavaScript:
 
-```csharp
-[Fact]
-public void Something_Is_The_Right_Length()
-{
-    var value = "something";
-    Assert.Equal(9, value.Length);
+```js
+function somethingIsTheRightLength() {
+    let value = "something";
+    console.assert(value.length === 9);
 }
+
+somethingIsTheRightLength();
 ```
 
 Rust does not require a separate framework or crate. The standard library
@@ -107,9 +113,9 @@ tests, such as `[Theory]` in xUnit.net.
 
 ## Mocking
 
-When writing tests for a .NET application or library, there exist several
-frameworks, like Moq and NSubstitute, to mock out the dependencies of types.
-There are similar crates for Rust too, like [`mockall`][mockall], that can
+<!--When writing tests for a .NET application or library, there exist several
+frameworks, like Moq and NSubstitute, to mock out the dependencies of types.-->
+There are<!-- similar--> crates for Rust too, like [`mockall`][mockall], that can
 help with mocking. However, it is also possible to use [conditional
 compilation] by making use of the [`cfg` attribute][cfg-attribute] as a simple
 means to mocking without needing to rely on external crates or frameworks. The
@@ -181,10 +187,8 @@ mod tests {
 
 ## Code coverage
 
-There is sophisticated tooling for .NET when it comes to analyzing test code
-coverage. In Visual Studio, the tooling is built-in and integrated. In Visual
-Studio Code, plug-ins exist. .NET developers might be familiar with [coverlet]
-as well.
+There is sophisticated tooling for JavaScript when it comes to analyzing test code
+coverage, such as Jest.
 
 Rust is providing [built-in code coverage implementations][built-in-cov] for
 collecting test code coverage.
@@ -217,6 +221,5 @@ in-line visual indicators about the line coverage in the source code editor.
 
 [coverage.gutters]: https://marketplace.visualstudio.com/items?itemName=ryanluker.vscode-coverage-gutters
 [tarpaulin]: https://github.com/xd009642/tarpaulin
-[coverlet]: https://github.com/coverlet-coverage/coverlet
 [built-in-cov]: https://doc.rust-lang.org/stable/rustc/instrument-coverage.html#test-coverage
 [project structure]: ../project-structure/index.md

src/threading/synchronization.md

@@ -1,36 +1,37 @@
 # Synchronization
 
 When data is shared between threads, one needs to synchronize read-write
-access to the data in order to avoid corruption. The C# offers the `lock`
-keyword as a synchronization primitive (which desugars to exception-safe use
-of `Monitor` from .NET):
-
-```csharp
-using System;
-using System.Threading;
-
-var dataLock = new object();
-var data = 0;
-var threads = new List<Thread>();
-
-for (var i = 0; i < 10; i++)
-{
-    var thread = new Thread(() =>
-    {
-        for (var j = 0; j < 1000; j++)
-        {
-            lock (dataLock)
-                data++;
+access to the data in order to avoid corruption. In JavaScript:
+
+```js
+let data = 0;
+let workers = [];
+let completedWorkers = 0;
+
+for (let i = 0; i < 10; i++) {
+    let worker = new Worker('data:text/javascript,' + encodeURIComponent(`
+        let partialData = 0;
+        for (let j = 0; j < 1000; j++) {
+            partialData++;
         }
-    });
-    threads.Add(thread);
-    thread.Start();
+        self.postMessage(partialData);
+    `));
+    
+    worker.onmessage = function(event) {
+        data += event.data;
+        completedWorkers++;
+        if (completedWorkers === 10) {
+            console.log(data);
+            workers.forEach(function(worker) {
+                worker.terminate();
+            });
+        }
+    };
+    
+    workers.push(worker);
+    worker.postMessage(null);
 }
 
-foreach (var thread in threads)
-    thread.Join();
-
-Console.WriteLine(data);
 ```
 
 In Rust, one must make explicit use of concurrency structures like `Mutex`: