diff --git a/WEB_SERVICE/WEB/_MEDIUM/TLS_HTTP/description.md b/WEB_SERVICE/WEB/_MEDIUM/TLS_HTTP/description.md
index 41f809e3..1f84f698 100644
--- a/WEB_SERVICE/WEB/_MEDIUM/TLS_HTTP/description.md
+++ b/WEB_SERVICE/WEB/_MEDIUM/TLS_HTTP/description.md
@@ -1,10 +1,237 @@
-Mobile Applications must use Transport Layer Security (TLS) to provide encryption at the transport layer and ensure the
-confidentiality and integrity of data in transit. This application does not use SSL/TLS and is vulnerable to traffic
-interception and modification.
+Clear text HTTP traffic refers to data transmitted between a mobile app and its backend server without any encryption, making it easily readable and susceptible to interception by malicious actors. This lack of encryption poses significant security risks for mobile apps. When sensitive information, such as login credentials, personal data, or financial details, is sent over clear text HTTP connections, it becomes vulnerable to eavesdropping and man-in-the-middle attacks.
 
-An attacker performing a man-in-the-middle (MITM) attack may:
+One of the primary risks associated with clear text HTTP traffic in mobile apps is the potential exposure of user data. Attackers can intercept and extract valuable information, leading to identity theft, unauthorized access to accounts, and misuse of personal data. Moreover, attackers can exploit these vulnerabilities to tamper with the app's content or inject malicious code into the communication channel.
 
-* Passively intercept the communication to access any sensitive data in transit like usernames, passwords, or credit
-  card number.
-* Actively inject or remove content to forge and omit information or inject malicious scripts
-* Actively redirect the communication to the attacker in the context of the initial trusted party
+Additionally, clear text HTTP traffic can compromise user privacy. Mobile apps often collect and transmit user data for analytics or targeted advertising purposes. Without encryption, this data is easily accessible to third parties, compromising users' confidentiality and potentially leading to privacy violations.
+
+Mobile apps that fail to implement secure communication protocols also face the risk of impersonation attacks. Attackers can create fake Wi-Fi networks or use other techniques to intercept traffic, pretending to be the legitimate backend server. Users unknowingly send their data to the attacker, who can then misuse it for malicious purposes.
+
+
+### Examples
+
+#### Dart
+
+```dart
+import 'dart:convert';
+import 'package:flutter/material.dart';
+import 'package:http/http.dart' as http;
+
+void main() => runApp(LoginApp());
+
+class LoginApp extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp(
+      title: 'Login App',
+      home: LoginPage(),
+    );
+  }
+}
+
+class LoginPage extends StatefulWidget {
+  @override
+  _LoginPageState createState() => _LoginPageState();
+}
+
+class _LoginPageState extends State<LoginPage> {
+  final TextEditingController _usernameController = TextEditingController();
+  final TextEditingController _passwordController = TextEditingController();
+  String _loginStatus = '';
+
+  void _performLogin() async {
+    final String username = _usernameController.text.trim();
+    final String password = _passwordController.text.trim();
+
+    // Simulate an HTTP request for login.
+    final String apiUrl = 'http://example.com/login'; 
+    final Map<String, dynamic> requestBody = {
+      'username': username,
+      'password': password,
+    };
+
+    final http.Response response = await http.post(
+      Uri.parse(apiUrl),
+      headers: {'Content-Type': 'application/json'},
+      body: json.encode(requestBody),
+    );
+
+    if (response.statusCode == 200) {
+      // Successful login
+      setState(() {
+        _loginStatus = 'Login successful!';
+      });
+    } else {
+      // Failed login
+      setState(() {
+        _loginStatus = 'Login failed. Please try again.';
+      });
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        title: Text('Login Page'),
+      ),
+      body: Padding(
+        padding: const EdgeInsets.all(16.0),
+        child: Column(
+          mainAxisAlignment: MainAxisAlignment.center,
+          crossAxisAlignment: CrossAxisAlignment.stretch,
+          children: [
+            TextFormField(
+              controller: _usernameController,
+              decoration: InputDecoration(labelText: 'Username'),
+            ),
+            TextFormField(
+              controller: _passwordController,
+              obscureText: true,
+              decoration: InputDecoration(labelText: 'Password'),
+            ),
+            SizedBox(height: 20),
+            ElevatedButton(
+              onPressed: _performLogin,
+              child: Text('Login'),
+            ),
+            SizedBox(height: 10),
+            Text(_loginStatus, textAlign: TextAlign.center),
+          ],
+        ),
+      ),
+    );
+  }
+}
+```
+
+#### Swift
+
+```swift
+import UIKit
+
+class LoginViewController: UIViewController {
+    @IBOutlet weak var usernameTextField: UITextField!
+    @IBOutlet weak var passwordTextField: UITextField!
+    @IBOutlet weak var loginStatusLabel: UILabel!
+    
+    override func viewDidLoad() {
+        super.viewDidLoad()
+    }
+    
+    @IBAction func loginButtonTapped(_ sender: UIButton) {
+        guard let username = usernameTextField.text?.trimmingCharacters(in: .whitespacesAndNewlines),
+              let password = passwordTextField.text?.trimmingCharacters(in: .whitespacesAndNewlines) else {
+            return
+        }
+        
+        // Simulate an HTTP request for login.
+        let apiUrl = "http://example.com/login" 
+        let requestBody: [String: Any] = [
+            "username": username,
+            "password": password
+        ]
+        
+        var request = URLRequest(url: URL(string: apiUrl)!)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        
+        do {
+            request.httpBody = try JSONSerialization.data(withJSONObject: requestBody, options: [])
+        } catch {
+            print("Error creating JSON data: \(error)")
+            return
+        }
+        
+        let task = URLSession.shared.dataTask(with: request) { data, response, error in
+            if let error = error {
+                print("Error: \(error)")
+                DispatchQueue.main.async {
+                    self.loginStatusLabel.text = "Login failed. Please try again."
+                }
+                return
+            }
+            
+            guard let data = data,
+                  let httpResponse = response as? HTTPURLResponse,
+                  httpResponse.statusCode == 200 else {
+                DispatchQueue.main.async {
+                    self.loginStatusLabel.text = "Login failed. Please try again."
+                }
+                return
+            }
+            
+            DispatchQueue.main.async {
+                self.loginStatusLabel.text = "Login successful!"
+            }
+        }
+        
+        task.resume()
+    }
+}
+```
+
+#### Kotlin
+
+```kotlin
+import android.os.Bundle
+import android.util.Log
+import androidx.appcompat.app.AppCompatActivity
+import kotlinx.android.synthetic.main.activity_login.*
+import org.json.JSONObject
+import java.io.OutputStreamWriter
+import java.net.HttpURLConnection
+import java.net.URL
+
+class LoginActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_login)
+
+        loginButton.setOnClickListener {
+            val username = usernameEditText.text.trim().toString()
+            val password = passwordEditText.text.trim().toString()
+
+            // Simulate an HTTP request for login.
+            val apiUrl = "https://example.com/login" 
+            val requestBody = JSONObject().apply {
+                put("username", username)
+                put("password", password)
+            }.toString()
+
+            Thread {
+                performLogin(apiUrl, requestBody)
+            }.start()
+        }
+    }
+
+    private fun performLogin(apiUrl: String, requestBody: String) {
+        try {
+            val url = URL(apiUrl)
+            val connection = url.openConnection() as HttpURLConnection
+            connection.requestMethod = "POST"
+            connection.setRequestProperty("Content-Type", "application/json")
+            connection.doOutput = true
+
+            val outputStreamWriter = OutputStreamWriter(connection.outputStream)
+            outputStreamWriter.write(requestBody)
+            outputStreamWriter.flush()
+
+            val responseCode = connection.responseCode
+            if (responseCode == HttpURLConnection.HTTP_OK) {
+                runOnUiThread {
+                    loginStatusLabel.text = "Login successful!"
+                }
+            } else {
+                runOnUiThread {
+                    loginStatusLabel.text = "Login failed. Please try again."
+                }
+            }
+        } catch (e: Exception) {
+            Log.e("LoginActivity", "Error: ${e.message}")
+            runOnUiThread {
+                loginStatusLabel.text = "Login failed. Please try again."
+            }
+        }
+    }
+}
+```
diff --git a/WEB_SERVICE/WEB/_MEDIUM/TLS_HTTP/meta.json b/WEB_SERVICE/WEB/_MEDIUM/TLS_HTTP/meta.json
index 9c95560d..91d9d40a 100644
--- a/WEB_SERVICE/WEB/_MEDIUM/TLS_HTTP/meta.json
+++ b/WEB_SERVICE/WEB/_MEDIUM/TLS_HTTP/meta.json
@@ -25,4 +25,4 @@
       "V9_1_1"
     ]
   }
-}
+}
\ No newline at end of file
diff --git a/WEB_SERVICE/WEB/_MEDIUM/TLS_HTTP/recommendation.md b/WEB_SERVICE/WEB/_MEDIUM/TLS_HTTP/recommendation.md
index 253dcf43..0ce85b53 100644
--- a/WEB_SERVICE/WEB/_MEDIUM/TLS_HTTP/recommendation.md
+++ b/WEB_SERVICE/WEB/_MEDIUM/TLS_HTTP/recommendation.md
@@ -1,6 +1,244 @@
-It is recommended to ensure the use of an encrypted channel for requests transmitting sensitive data. It is, however
-highly recommended to encrypt all requests made by the application, as the interception and modification of non
-sensitive requests could be leveraged to access sensitive data.
+To mitigate the risks associated with clear text HTTP traffic in mobile apps, it is imperative to implement secure communication protocols and best practices. Below are some detailed recommendations to enhance the security of mobile app communications:
 
-The encrypted channel should use secure protocols and cipher suites, do not develop custom encryption protocols or
-algorithms.
+- Adopt HTTPS Encryption: The most fundamental step is to use HTTPS (HTTP Secure) for all communication between the mobile app and the backend server. HTTPS encrypts data during transmission, ensuring that sensitive information remains confidential and secure. Obtain an SSL/TLS certificate from a trusted Certificate Authority (CA) and enforce HTTPS connections for all API endpoints and data transfers.
+
+- Certificate Pinning: Implement certificate pinning to enhance the security of HTTPS connections. This involves hardcoding the server's SSL certificate or its public key within the mobile app. By doing so, the app ensures that it only communicates with the intended server, preventing man-in-the-middle attacks where attackers attempt to use their own certificates.
+
+- Enable HSTS (HTTP Strict Transport Security): Utilize HSTS headers to instruct the app's web browser to always use HTTPS connections, even if the user mistakenly types "http://" in the URL. This prevents any potential downgrade attacks and ensures all communications are encrypted.
+
+- Use the Latest TLS Version: Ensure that the mobile app uses the latest version of the TLS (Transport Layer Security) protocol to take advantage of the most robust security features and encryption algorithms.
+
+- Implement Certificate Checking: Configure the app to check for revoked or expired SSL certificates to avoid interactions with potentially compromised servers.
+
+- Sensitive Data Encryption: Encrypt sensitive data stored on the device or transmitted to the server. Utilize strong encryption algorithms and securely manage encryption keys, this can add an extra layer of security to data transmission.
+
+- Secure Data Transmission for All APIs: Evaluate all APIs used by the app and ensure that they also use HTTPS for data transmission. This includes third-party APIs and services integrated into the app.
+# Code Examples:
+
+### Dart
+
+```dart
+import 'dart:convert';
+import 'package:flutter/material.dart';
+import 'package:http/http.dart' as http;
+
+void main() => runApp(LoginApp());
+
+class LoginApp extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp(
+      title: 'Login App',
+      home: LoginPage(),
+    );
+  }
+}
+
+class LoginPage extends StatefulWidget {
+  @override
+  _LoginPageState createState() => _LoginPageState();
+}
+
+class _LoginPageState extends State<LoginPage> {
+  final TextEditingController _usernameController = TextEditingController();
+  final TextEditingController _passwordController = TextEditingController();
+  String _loginStatus = '';
+
+  void _performLogin() async {
+    final String username = _usernameController.text.trim();
+    final String password = _passwordController.text.trim();
+
+    // Simulate a secure HTTPS request for login (Replace this with your actual secure API endpoint).
+    final String apiUrl = 'https://www.example.com/login'; 
+    final Map<String, dynamic> requestBody = {
+      'username': username,
+      'password': password,
+    };
+
+    final http.Response response = await http.post(
+      Uri.parse(apiUrl),
+      headers: {'Content-Type': 'application/json'},
+      body: json.encode(requestBody),
+    );
+
+    if (response.statusCode == 200) {
+      // Successful login
+      setState(() {
+        _loginStatus = 'Login successful!';
+      });
+    } else {
+      // Failed login
+      setState(() {
+        _loginStatus = 'Login failed. Please try again.';
+      });
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        title: Text('Login Page'),
+      ),
+      body: Padding(
+        padding: const EdgeInsets.all(16.0),
+        child: Column(
+          mainAxisAlignment: MainAxisAlignment.center,
+          crossAxisAlignment: CrossAxisAlignment.stretch,
+          children: [
+            TextFormField(
+              controller: _usernameController,
+              decoration: InputDecoration(labelText: 'Username'),
+            ),
+            TextFormField(
+              controller: _passwordController,
+              obscureText: true,
+              decoration: InputDecoration(labelText: 'Password'),
+            ),
+            SizedBox(height: 20),
+            ElevatedButton(
+              onPressed: _performLogin,
+              child: Text('Login'),
+            ),
+            SizedBox(height: 10),
+            Text(_loginStatus, textAlign: TextAlign.center),
+          ],
+        ),
+      ),
+    );
+  }
+}
+```
+
+### Swift
+
+```swift
+import UIKit
+
+class LoginViewController: UIViewController {
+    @IBOutlet weak var usernameTextField: UITextField!
+    @IBOutlet weak var passwordTextField: UITextField!
+    @IBOutlet weak var loginStatusLabel: UILabel!
+    
+    override func viewDidLoad() {
+        super.viewDidLoad()
+    }
+    
+    @IBAction func loginButtonTapped(_ sender: UIButton) {
+        guard let username = usernameTextField.text?.trimmingCharacters(in: .whitespacesAndNewlines),
+              let password = passwordTextField.text?.trimmingCharacters(in: .whitespacesAndNewlines) else {
+            return
+        }
+        
+        // Simulate a secure HTTPS request for login (Replace this with your actual secure API endpoint).
+        let apiUrl = "https://www.example.com/login" 
+        let requestBody: [String: Any] = [
+            "username": username,
+            "password": password
+        ]
+        
+        var request = URLRequest(url: URL(string: apiUrl)!)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        
+        do {
+            request.httpBody = try JSONSerialization.data(withJSONObject: requestBody, options: [])
+        } catch {
+            print("Error creating JSON data: \(error)")
+            return
+        }
+        
+        let task = URLSession.shared.dataTask(with: request) { data, response, error in
+            if let error = error {
+                print("Error: \(error)")
+                DispatchQueue.main.async {
+                    self.loginStatusLabel.text = "Login failed. Please try again."
+                }
+                return
+            }
+            
+            guard let data = data,
+                  let httpResponse = response as? HTTPURLResponse,
+                  httpResponse.statusCode == 200 else {
+                DispatchQueue.main.async {
+                    self.loginStatusLabel.text = "Login failed. Please try again."
+                }
+                return
+            }
+            
+            DispatchQueue.main.async {
+                self.loginStatusLabel.text = "Login successful!"
+            }
+        }
+        
+        task.resume()
+    }
+}
+```
+
+### Kotlin
+
+```kotlin
+import android.os.Bundle
+import android.util.Log
+import androidx.appcompat.app.AppCompatActivity
+import kotlinx.android.synthetic.main.activity_login.*
+import org.json.JSONObject
+import java.io.OutputStreamWriter
+import java.net.HttpURLConnection
+import java.net.URL
+
+class LoginActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_login)
+
+        loginButton.setOnClickListener {
+            val username = usernameEditText.text.trim().toString()
+            val password = passwordEditText.text.trim().toString()
+
+            // Simulate a secure HTTPS request for login (Replace this with your actual secure API endpoint).
+            val apiUrl = "https://www.example.com/login" 
+            val requestBody = JSONObject().apply {
+                put("username", username)
+                put("password", password)
+            }.toString()
+
+            Thread {
+                performLogin(apiUrl, requestBody)
+            }.start()
+        }
+    }
+
+    private fun performLogin(apiUrl: String, requestBody: String) {
+        try {
+            val url = URL(apiUrl)
+            val connection = url.openConnection() as HttpURLConnection
+            connection.requestMethod = "POST"
+            connection.setRequestProperty("Content-Type", "application/json")
+            connection.doOutput = true
+
+            val outputStreamWriter = OutputStreamWriter(connection.outputStream)
+            outputStreamWriter.write(requestBody)
+            outputStreamWriter.flush()
+
+            val responseCode = connection.responseCode
+            if (responseCode == HttpURLConnection.HTTP_OK) {
+                runOnUiThread {
+                    loginStatusLabel.text = "Login successful!"
+                }
+            } else {
+                runOnUiThread {
+                    loginStatusLabel.text = "Login failed. Please try again."
+                }
+            }
+        } catch (e: Exception) {
+            Log.e("LoginActivity", "Error: ${e.message}")
+            runOnUiThread {
+                loginStatusLabel.text = "Login failed. Please try again."
+            }
+        }
+    }
+}
+
+```