Merge branch 'main' into log-entry

Author: Radhika-okhade

bin/concept-of-the-week.txt

@@ -1 +1 @@
-content/typescript/concepts/interfaces/interfaces.md
+content/sklearn/concepts/probability-calibration/probability-calibration.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/cloud-computing/concepts/cloud-storage/cloud-storage.md

@@ -0,0 +1,46 @@
+---
+Title: 'Cloud Storage'
+Description: 'A service that allows users to store and access data remotely over the internet.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Cloud Computing'
+  - 'Storage'
+  - 'Data'
+  - 'Infrastructure'
+CatalogContent:
+  - 'foundations-of-cloud-computing'
+  - 'paths/back-end-engineer-career-path'
+---
+
+**Cloud storage** provides on-demand storage services over the internet, eliminating the need for physical storage infrastructure. Users can store, access, and manage data remotely through cloud providers, paying only for the storage they use.
+
+## Object storage
+
+Designed for storing large amounts of unstructured data. Data is stored as objects with metadata and unique identifiers. Object storage is highly scalable and commonly used for:
+
+- Backup and archival data
+- Media files (images, videos, audio)
+- Web content and static assets
+- Big data analytics
+
+## Block storage
+
+Provides raw storage volumes that can be attached to virtual machines. Data is stored in fixed-size blocks and is ideal for:
+
+- Operating system storage
+- Database storage
+- High-performance applications
+- Applications requiring low latency
+
+## File storage
+
+Shared file systems that can be accessed by multiple users and applications. It organizes data in a hierarchical structure and is suitable for:
+
+- Shared document storage
+- Application data that requires file system access
+- Content management systems
+- Collaborative work environments
+
+All major cloud providers offer services across these three storage categories, each optimized for different performance requirements and use cases.

content/cpp/concepts/deque/terms/back/back.md

@@ -0,0 +1,81 @@
+---
+Title: '.back()'
+Description: 'Returns a reference to the last element in the deque.'
+Subjects:
+  - 'Computer Science'
+  - 'Game Development'
+Tags:
+  - 'Containers'
+  - 'Data Structures'
+  - 'Deques'
+  - 'Methods'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+In C++, the **`.back()`** [method](https://www.codecademy.com/resources/docs/cpp/methods) returns a reference to the last element in a [deque](https://www.codecademy.com/resources/docs/cpp/deque). It allows direct access to that element for reading or modifying without removing it.
+
+> **Note:** Calling `.back()` on an empty deque leads to undefined behavior. Check with [`.empty()`](https://www.codecademy.com/resources/docs/cpp/deque/empty) before using `.back()`.
+
+## Syntax
+
+```pseudo
+dequeName.back();
+```
+
+**Parameters:**
+
+This method does not take any parameters.
+
+**Return value:**
+
+Returns a reference to the last element of the deque. If the deque is `const`, it returns a `const` reference.
+
+## Example: Accessing and Updating the Last Element
+
+This example retrieves the last number in a deque, updates it, and displays the change:
+
+```cpp
+#include <deque>
+#include <iostream>
+
+int main() {
+  std::deque<int> scores = {45, 67, 89};
+
+  std::cout << "Last score: " << scores.back() << std::endl;
+
+  // Update the last element
+  scores.back() = 100;
+
+  std::cout << "Updated last score: " << scores.back() << std::endl;
+  return 0;
+}
+```
+
+This program produces the following output:
+
+```shell
+Last score: 89
+Updated last score: 100
+```
+
+## Codebyte Example: Using `.back()` in a Conditional Check
+
+This example shows how `.back()` can be used to verify or modify the final value in a deque:
+
+```codebyte/cpp
+#include <deque>
+#include <iostream>
+
+int main() {
+  std::deque<std::string> tasks = {"plan", "write", "review"};
+
+  if (tasks.back() == "review") {
+    tasks.back() = "submit"; // Update the last task
+  }
+
+  std::cout << "Final task: " << tasks.back() << std::endl;
+  return 0;
+}
+```

content/cpp/concepts/deque/terms/front/front.md

@@ -0,0 +1,114 @@
+---
+Title: '.front()'
+Description: 'Returns a reference to the first element of the deque'
+Subjects:
+  - 'Computer Science'
+  - 'Game Development'
+Tags:
+  - 'Classes'
+  - 'Containers'
+  - 'Deques'
+  - 'OOP'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+In C++, the **`.front()`** [method](https://www.codecademy.com/resources/docs/cpp/methods) returns a reference to the first element in the [deque](https://www.codecademy.com/resources/docs/python/deque).
+
+## Syntax
+
+```pseudo
+deque_name.front()
+```
+
+**Parameters:**
+
+`.front()` does not take any parameters
+
+**Return value:**
+
+- Returns a reference to the first element of the deque.
+  - For a non-const deque, returns `T&` (modifiable).
+  - For a const deque, returns const `T&` (read-only).
+
+## Example
+
+The example below demonstrates use of `.front()` to access the first element in a deque:
+
+```cpp
+#include <iostream>
+#include <deque>
+
+int main() {
+  // Create a deque of integers
+  std::deque<int> numbers;
+
+  // Add some elements to the deque
+  numbers.push_back(100);
+  numbers.push_back(200);
+  numbers.push_back(300);
+
+  // Access the first element using .front()
+  std::cout << "First element: " << numbers.front() << std::endl;
+
+  // Modify the first element
+  numbers.front() = 50;
+
+  // Display updated deque contents
+  std::cout << "Updated deque: ";
+  for (int num : numbers) {
+    std::cout << num << " ";
+  }
+  std::cout << std::endl;
+
+  return 0;
+}
+```
+
+The output of this program will be:
+
+```shell
+First element: 100
+Updated deque: 50 200 300
+```
+
+This shows that `.front()` allows both access and modification of the deque’s first element.
+
+## Codebyte Example
+
+Run the following codebyte example to understand the use of `.front()` method:
+
+```codebyte/cpp
+#include <iostream>
+#include <deque>
+#include <string>
+
+int main() {
+  // Create a deque of strings
+  std::deque<std::string> myDeque;
+
+  // Add elements to the deque
+  myDeque.push_back("Hello");
+  myDeque.push_back("World");
+  myDeque.push_back("!");
+
+  // Print the front element
+  std::cout << "Front element before change: " << myDeque.front() << std::endl;
+
+  // Modify the front element
+  myDeque.front() = "Hi";
+
+  // Print the modified front element
+  std::cout << "Front element after change: " << myDeque.front() << std::endl;
+
+  // Print all elements of the deque
+  std::cout << "Complete deque: ";
+  for (const auto& str : myDeque) {
+    std::cout << str << " ";
+  }
+  std::cout << std::endl;
+
+  return 0;
+}
+```

content/cpp/concepts/deque/terms/max-size/max-size.md

@@ -0,0 +1,79 @@
+---
+Title: '.max_size()'
+Description: 'Returns the maximum number of elements a deque can hold.'
+Subjects:
+  - 'Computer Science'
+  - 'Game Development'
+Tags:
+  - 'Classes'
+  - 'Containers'
+  - 'Deques'
+  - 'OOP'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+In C++, the **`.max_size()`** [method](https://www.codecademy.com/resources/docs/cpp/methods) returns the maximum number of elements a deque can hold. This value reflects the maximum possible size based on system or library constraints. However, it does not guarantee that the container can actually grow to that size—memory allocation may still fail before reaching the reported limit.
+
+## Syntax
+
+```pseudo
+dequeName.max_size();
+```
+
+**Parameters:**
+
+The method does not take any parameters.
+
+**Return value:**
+
+Returns the maximum number of elements the deque can potentially hold as a value of type `size_type`.
+
+## Example
+
+In this example, the maximum possible number of elements a deque can hold on the system is retrieved:
+
+```cpp
+#include <iostream>
+#include <deque>
+
+int main() {
+  std::deque<int> mydeque;
+
+  // Display the maximum possible number of elements
+  std::cout << "Maximum possible elements: " << mydeque.max_size() << '\n';
+}
+```
+
+Example output on a 64-bit system:
+
+```shell
+Maximum possible elements: 4611686018427387903
+```
+
+## Codebyte Example
+
+In this example, a requested size is compared with the maximum possible size of a deque, and the container is resized only if the size is allowed:
+
+```codebyte/cpp
+#include <iostream>
+#include <deque>
+
+int main() {
+
+  std::deque<int> mydeque;
+  unsigned int requested_size = 5;  // example requested size
+
+  if (requested_size < mydeque.max_size()) {
+    mydeque.resize(requested_size);
+    std::cout << "Deque resized to " << requested_size << " elements.\n";
+  } else {
+    std::cout << "Requested size exceeds maximum allowed.\n";
+  }
+
+  std::cout << "Current deque size: " << mydeque.size() << std::endl;
+
+  return 0;
+}
+```