How to change the root password for MySQL in XAMPP?

By default, when you install XAMPP in your windows machine, the root password for the MySQL is set to empty. But this is not recommended, as the MySQL database without a password will be accessible to everyone. To avoid this, a proper/secure password must be set to the user root. To do it in XAMPP, there are two ways.

Method 1: reset XAMPP MySQL root password through web interface:

After you started your XAMPP server, go to the browser and type the URL http://localhost/security/ (incase you've modified XAMPP server port, you need to include that port number also in previous URL). The security page will be shown where you can change the root password for MySQL. This will update the phpMyAdmin config also.

Method 2: reset XAMPP MySQL root password through SQL update:

1. Start the Apache Server and MySQL instances from the XAMPP control panel.
2. After the server started, open any web browser and give http://localhost:8090/phpmyadmin/ (if you are running XAMPP on 8090 port). This will open the phpMyAdmin interface. Using this interface we can manager the MySQL server from the web browser.
3. In the phpMyAdmin window, select SQL tab from the right panel. This will open the SQL tab where we can run the SQL queries.
4. Now type the following query in the textarea and click Go
   UPDATE mysql.user SET Password=PASSWORD('password') WHERE User='root'; FLUSH PRIVILEGES;
5. Now you will see a message saying that the query has been executed successfully.
6. If you refresh the page, you will be getting a error message. This is because the phpMyAdmin configuration file is not aware of our newly set root passoword. To do this we have to modify the phpMyAdmin config file.
7. Open the file [XAMPP Installation Path] / phpmyadmin / config.inc.php in your favorite text editor.
8. Search for the string $cfg\['Servers'\]\[$i\]['password'] = ''; and change it to like this, $cfg\['Servers'\]\[$i\]['password'] = 'password'; Here the 'password' is what we set to the root user using the SQL query.
9. Now all set to go. Save the config.inc.php file and restart the XAMPP server. 

.Net c# parallel yield

yield is a very useful keyword in C# that allows you to create dynamic enumerators of stuffs without having to fill in a List<T> of things you want to return first. The generated code builds a state machine that will go forward, step by step, whenever the caller calls MoveNext on the IEnumerable it gets back (usually using foreach).

static void Main(string[] args) {     var input = new[] { "A", "B", "C" };       Console.WriteLine(String.Join("\n", Process(input))); }   static IEnumerable<string> Process(IEnumerable<string> input) {     if (input == null)         throw new ArgumentNullException("input");       foreach (var item in input)     {         yield return "Process " + item;     } }   // Output : // Process A // Process B // Process C

The second really useful thing is Parallel.ForEach. Whenever you have to process loads of independent data that are CPU hungry you can launch the process in parallel and have it scheduled for you by the .NET runtime.

static void Main(string[] args) {     var input = new[] { "A", "B", "C" };       Stopwatch w = new Stopwatch();     w.Start();     Process(input);     w.Stop();       Console.WriteLine("{0}s ", w.Elapsed.TotalSeconds); }   static void Process(IEnumerable<string> input) {     if (input == null)         throw new ArgumentNullException("input");       Parallel.ForEach(input, item =>         {             // Something long             Thread.Sleep(1000);         }); }   // Output : // ~ 1s although we had 3 stuffs that each took 1s

What if we could write that?

static void Main(string[] args) {     var input = new[] { "A", "B", "C" };       Stopwatch w = new Stopwatch();     w.Start();     var result = Process(input);     w.Stop();       Console.WriteLine("{0}s ", w.Elapsed.TotalSeconds);     Console.WriteLine(String.Join("\n", result)); }   static IEnumerable<string> Process(IEnumerable<string> input) {     if (input == null)         throw new ArgumentNullException("input");       Parallel.ForEach(input, item =>         {             // Something long             Thread.Sleep(1000);                           // >>>> THE POWER !!             yield return "Process " + item;         }); }

But no we can’t because “The yield statement cannot be used inside an anonymous method or lambda expression“.
You obviously can’t mix those two pieces of magic together. In fact, if we could this would produce some of the weirdest bugs ever if something went wrong. But maybe we can’t build something that looks like it, for the sake of doing it?

static void Main(string[] args) {     var input = new[] { "A", "B", "C" };       Stopwatch w = new Stopwatch();     w.Start();     var result = Process(input);       Trace.WriteLine(String.Format("{0}s before enumerating", w.Elapsed.TotalSeconds));     Trace.WriteLine(String.Format(String.Join("\n", result)));     Trace.WriteLine(String.Format("{0}s after enumerating", w.Elapsed.TotalSeconds)); }   static IEnumerable<string> Process(IEnumerable<string> input) {     if (input == null)         throw new ArgumentNullException("input");       var workQueue = new ConcurrentQueue<string>();     Exception workException = null;     var completed = false;       // This task will run on its side in another thread     Task.Run(() =>     {         try         {             Parallel.ForEach(input, item =>                 {                     // Something long                     Thread.Sleep(1000);                       // Push our results here                     workQueue.Enqueue("Process " + item);                 });         }         catch (Exception ex)         {             // We don't want a crash to be lost in another thread             // so we have to bring it back somehow on the main thread             workException = ex;         }           completed = true;     });       // Not the most elegant, but it's just for fun so ...     while (!completed)     {         string item;         if (workQueue.TryDequeue(out item))             yield return item;         else             Thread.Sleep(1); // remember, just for fun     }       // We don't want to lose the last items     string finalItem;     while (workQueue.TryDequeue(out finalItem))         yield return finalItem;       // Buble the exception if there's one     if (workException != null)     {         throw new Exception("Error while doing stuffs", workException);     } }

Output:

0.00039s before enumerating
Process B
Process A
Process C
1.0398348s after enumerating

Notice than we did have an “yield behavior” as the processing was not executed on the call to Process, and how the whole process took 1s where it has 3 items that each took 1s. We also don’t have a reliable order anymore, it could have been any combination of B, A and C.