Merge branch 'main' into update-bitwise-operator

Author: mamtawardhani

CONTRIBUTING.md

@@ -133,14 +133,6 @@ To link your Codecademy user profile to GitHub:
 - Typos/bugs
 - Plagiarism
 
-## What is the policy for using generative AI?
-
-We will not accept entries that were exclusively generated through an AI tool. We have this policy because:
-
-- AI-generated content is often confidently incorrect, leading to the spread of inaccurate or misleading information.
-- We provide authorship credit for submissions, and to submit AI-generated work under one's own name would be a violation of our plagiarism policy.
-- Docs is an educational space for people to learn how to write effective technical documentation. Using generative AI, at this point, negatively impacts that desired learning goal.
-
 ## How do we update a PR branch?
 
 To keep your PR branch up to date, navigate to the branch on your fork. Then press `Fetch upstream` and `Fetch and merge`.
@@ -158,10 +150,60 @@ git rebase upstream main
 git push
 ```
 
-## Additional Resources
+## Can I use AI tools when contributing?
+
+Yes! You can use AI tools to help create our Docs entries. [Codecademy Docs](https://github.com/Codecademy/docs) is an open-source project designed to help you learn how to contribute to open source, collaborate with the community, and use GitHub. It’s not meant to test whether you can write perfect technical content on your own.
+
+AI can assist you with drafting, rewriting, or structuring content. However, you are responsible for ensuring your work meets Codecademy’s quality and [style standards](https://github.com/Codecademy/docs/blob/main/documentation/content-standards.md). AI is a tool to help you, but it doesn't replace the standards we expect.
+
+You're accountable for all AI-assisted content.
+
+You may use AI to generate drafts or refine your writing, but you must personally review and improve all AI-assisted content before submitting. Every entry must follow:
+
+- [The Docs entry template](https://github.com/Codecademy/docs/blob/main/documentation/term-entry-template.md)
+- [Our content standards](https://github.com/Codecademy/docs/blob/main/documentation/content-standards.md)
+- [Our style guidelines](https://github.com/Codecademy/docs/blob/main/documentation/style-guide.md)
+
+> **Note:** If we detect plagiarism in your entry, you will be banned from contributing to Docs.
+
+## What you need to verify
+
+Even if AI produced the initial version of the entry, you must ensure that:
+
+- The content is accurate, technically correct, and fact-checked.
+- All explanations are clear and aligned with Codecademy Docs writing style.
+- Code examples compile or run correctly when required.
+- The text is not plagiarized or copied from external sources.
+- The final entry sounds intentional, not generic, or filled with filler text.
+- The formatting follows the Docs template exactly.
+
+AI output often contains vague definitions, hallucinated details, or inconsistent explanations. You must correct and refine these issues before submitting a pull request.
+
+## Quality standards apply to all entries
+
+Regardless of how you created the content, every entry must:
+
+- Use original wording.
+- Include accurate definitions and examples.
+- Follow the required structure, headings, and formatting.
+- Maintain a simple, educational, and neutral tone.
+- Avoid unnecessary complexity or overly broad explanations.
+- Fit the scope of a Docs reference entry.
+
+> **Note:** If your submission doesn't meet these standards, we'll ask you to revise it.
+
+## What happens during review?
+
+Maintainers (Codecademy’s content team who reviews all contributions) may request edits on any AI-assisted entry if it:
+
+- Does not follow our template.
+- Contains unclear, generic, or contradictory information.
+- Includes mistakes or technical inaccuracies.
+- Appears copied.
+- Lacks the clarity expected from Docs entries.
 
-- [How to Contribute to Docs](https://dev.to/codecademy/how-to-contribute-to-codecademy-docs-1a77) article
+You're expected to respond to feedback and make the requested improvements within 1 week, or your PR will be closed due to inactivity.
 
-Remember, if you ever have any questions at all, we're always here to help in the [Codecademy Forums](https://discuss.codecademy.com/c/community/community-docs/2205) and [Codecademy Discord](https://discord.com/invite/codecademy).
+Remember, if you ever have any questions at all, we're always here to help in the [Codecademy Forums](https://community.codecademy.com/).
 
 If you find any bugs or errors in the content, feel free to file an issue [here](https://github.com/Codecademy/docs/issues/new?assignees=Name+here&labels=bug&template=bug_reports.yml&title=%5BBug%2FError%5D+Subject%3A+Entry+Name)! 🖖

README.md

@@ -56,7 +56,7 @@ Here's how you can contribute to Codecademy Docs:
 - Submit your work:
   - Submit a Pull Request of your entry for your assigned Issue.
 - Collaborate and provide feedback:
-  - Reply to the thread on [Possible Content Discussion](https://discuss.codecademy.com/t/find-a-starting-point-possible-content-discussion/745868) to share ideas and collaborate with other contributors, maintainers, or super users to determine good future issues.
+  - Reply to the thread on [Possible Content Discussion](https://community.codecademy.com/) to share ideas and collaborate with other contributors, maintainers, or super users to determine good future issues.
   - Share your thoughts in this [Docs feedback form](https://codecademyready.typeform.com/to/hzVIWDgz) to tell us how we can improve Docs!
 
 Whether you are a code newbie or a seasoned hacker, there's something for you!

bin/concept-of-the-week.txt

@@ -1 +1 @@
-content/typescript/concepts/interfaces/interfaces.md
+content/postgresql/concepts/subscripts/subscripts.md

content/c-sharp/concepts/conditionals/conditionals.md

@@ -127,7 +127,7 @@ Is this condition true ? Run this if yes : Run this if no;
 In the example below, the condition that is checked is if `input1` is equal to 10. If that condition is true, it returns the first string. Otherwise, it returns the second string:
 
 ```cs
-string getInput1(int input1) => input1 === 10 ? "I returned true" : "I returned false";
+string getInput1(int input1) => input1 == 10 ? "I returned true" : "I returned false";
 
 Console.WriteLine(getInput1(10)); // Output: "I returned true"
 Console.WriteLine(getInput1(5)); // Output: "I returned false"

content/c-sharp/concepts/math-functions/terms/abs/abs.md

@@ -1,5 +1,5 @@
 ---
-Title: 'Abs()'
+Title: '.Abs()'
 Description: 'Returns the absolute value of a specified number.'
 Subjects:
   - 'Computer Science'

content/c-sharp/concepts/math-functions/terms/acosh/acosh.md

@@ -0,0 +1,80 @@
+---
+Title: 'Acosh()'
+Description: 'Returns the inverse hyperbolic cosine of a specified number.'
+Subjects:
+  - 'Computer Science'
+  - 'Web Development'
+Tags:
+  - 'Functions'
+  - 'Math'
+  - 'Methods'
+  - 'Numbers'
+CatalogContent:
+  - 'learn-c-sharp'
+  - 'paths/computer-science'
+---
+
+The **`Math.Acosh()`** method returns the inverse hyperbolic cosine (also known as hyperbolic arccosine) of a specified number. It computes the value whose hyperbolic cosine equals the given number.
+
+## Syntax
+
+```pseudo
+Math.Acosh(number);
+```
+
+**Parameters:**
+
+- `number`: A double-precision floating-point value greater than or equal to `1`, for which to compute the inverse hyperbolic cosine.
+
+**Return value:**
+
+- The inverse hyperbolic cosine of the specified number in radians as a `double`.
+- `NaN` if the input is less than `1` or `NaN`.
+
+## Example: Basic Usage of `Math.Acosh()`
+
+This example calculates the inverse hyperbolic cosine of a number using `Math.Acosh()` and displays the result in radians:
+
+```cs
+using System;
+
+public class Example
+{
+  public static void Main()
+  {
+    double number = 1.5;
+    double result = Math.Acosh(number);
+    Console.WriteLine($"Math.Acosh({number}) = {result} radians");
+  }
+}
+```
+
+This example outputs the following:
+
+```shell
+Math.Acosh(1.5) = 0.9624236501192069 radians
+```
+
+## Codebyte Example
+
+In this example, the `Math.Acosh()` method is used to calculate the inverse hyperbolic cosine of a specified number in radians and degrees:
+
+```codebyte/csharp
+using System;
+
+public class Example {
+  public static void Main() {
+    double number = 100.0;
+
+    // Calculate Acosh in radians
+    double resultRadians = Math.Acosh(number);
+
+    // Convert radians to degrees
+    double resultDegrees = resultRadians * (180.0 / Math.PI);
+
+    // Display results
+    Console.WriteLine($"Math.Acosh({number}) = {resultRadians} radians");
+    Console.WriteLine($"Math.Acosh({number}) = {resultDegrees} degrees");
+  }
+}
+```

content/c-sharp/concepts/math-functions/terms/atanh/atanh.md

@@ -0,0 +1,82 @@
+---
+Title: 'Atanh()'
+Description: 'Returns the inverse hyperbolic tangent of a number.'
+Subjects:
+  - 'Computer Science'
+  - 'Code Foundations'
+Tags:
+  - 'Arithmetic'
+  - 'Methods'
+  - 'Numbers'
+CatalogContent:
+  - 'learn-c-sharp'
+  - 'paths/computer-science'
+---
+
+The **`Math.Atanh()`** method returns the inverse hyperbolic tangent (hyperbolic arctangent) of a specified number. The inverse hyperbolic tangent is the value whose hyperbolic tangent is the input number.
+
+## Syntax
+
+```pseudo
+Math.Atanh(value);
+```
+
+**Parameters:**
+
+- `value`: A double-precision floating-point number in the range `-1` to `1`, representing the hyperbolic tangent value.
+
+**Return value:**
+
+The `Math.Atanh()` method returns the inverse hyperbolic tangent of the given `value` as a `double`.
+
+It returns:
+
+- `NaN` (Not a Number) if the `value` is less than `-1` or greater than `1`.
+- `NegativeInfinity` if the `value` is exactly `-1`.
+- `PositiveInfinity` if the `value` is exactly `1`.
+
+## Example: Basic Usage of `Math.Atanh()`
+
+The following example demonstrates the basic usage of `Math.Atanh()`:
+
+```cs
+using System;
+
+class Program
+{
+  static void Main()
+  {
+    double value = 0.5;
+    double result = Math.Atanh(value);
+    Console.WriteLine($"Atanh({value}) = {result}");
+  }
+}
+```
+
+This will output:
+
+```shell
+Atanh(0.5) = 0.5493061443340548
+```
+
+## Codebyte Example
+
+In this example, different values are passed to `Math.Atanh()` to observe how the result changes:
+
+```codebyte/csharp
+using System;
+
+class Program
+{
+  static void Main()
+  {
+    double[] testValues = { 0.25, 0.5, 0.75, 0.9, -0.5 };
+
+    foreach (double value in testValues)
+    {
+      double result = Math.Atanh(value);
+      Console.WriteLine($"Atanh({value}) = {result:F4}");
+    }
+  }
+}
+```

content/c-sharp/concepts/math-functions/terms/bigmul/bigmul.md

@@ -0,0 +1,86 @@
+---
+Title: '.BigMul()'
+Description: 'Multiplies two integer values and returns the full extended result to prevent overflow.'
+Subjects:
+  - 'Computer Science'
+  - 'Code Foundations'
+Tags:
+  - 'Methods'
+  - 'Numbers'
+  - 'Arithmetic'
+CatalogContent:
+  - 'learn-c-sharp'
+  - 'paths/computer-science'
+---
+
+The **`Math.BigMul()`** method multiplies two integer values and returns the full extended result to avoid overflow. It ensures that the product fits within a larger data type when the operands are 32-bit or 64-bit integers.
+
+## Syntax
+
+```pseudo
+Math.BigMul(x, y);
+```
+
+**Parameters:**
+
+- `x`, `y`: The integers to be multiplied. These can be of type `int`, `uint`, `long`, or `ulong`.
+
+**Return value:**
+
+Returns the full product of `x` and `y` as a single 64-bit or 128-bit integer, depending on the input type:
+
+- If `x` and `y` are of type `int` or `uint`, the return type is `long` and `ulong`, respectively.
+- If `x` and `y` are of type `long` or `ulong`, the return type is `Int128` and `UInt128`, respectively.
+
+> **Note:** The `Int128` and `UInt128` types were introduced in .NET 7. In earlier versions, `Math.BigMul(long, long, out long high)` can be used to obtain the high and low 64-bit parts of the product.
+
+## Example: Basic Usage
+
+In this example, the full product of two `int` values is calculated without overflow:
+
+```cs
+using System;
+
+public class Example {
+  public static void Main() {
+    // Integer values (32-bit)
+    int intX = 100000;
+    int intY = 500000;
+
+    // Compute the product safely
+    long intResult = Math.BigMul(intX, intY);
+
+    Console.WriteLine($"Math.BigMul({intX}, {intY}) = {intResult}");
+  }
+}
+```
+
+This example outputs the following:
+
+```shell
+Math.BigMul(100000, 500000) = 50000000000
+```
+
+## Codebyte Example
+
+The following example demonstrates the use of `Math.BigMul()` to calculate the product of two integers that would normally cause an overflow with standard multiplication:
+
+```codebyte/csharp
+using System;
+
+public class Example {
+  public static void Main (string[] args) {
+    int x = 200000;
+    int y = 300000;
+
+    // Normal multiplication (overflow)
+    int normalResult = x * y;
+
+    // Math.BigMul() (no overflow)
+    long bigMulResult = Math.BigMul(x, y);
+
+    Console.WriteLine($"Normal multiplication (overflow): {normalResult}");
+    Console.WriteLine($"BigMul (no overflow): {bigMulResult}");
+  }
+}
+```