How to find kickass torrent proxy servers?

How to find kickass torrent proxy servers?  As you can see Google is blocking relevant searches.

Easy, use baidu

www.baidu.com

Old laptop stopped working after Windows 10 upgrade?

If you are like me has a trusty old laptop you bought back in Windows 7 days and it is still working really well, well except it wouldn't install Windows 10 and Microsoft keeps on trying to force you to update, and the latest patch just render it unbootable. There is hope :)

Install Ubuntu and run Windows 10 under vmware.

Ubuntu has come a long way and it is really refine. It is free and will work with older hardwares while supporting modern features (harddrive encryption) with lots of free software

Example on how to use C++ regex_token_iterator

 #pragma once   
 #pragma warning(disable:4996)   
 #define _SCL_SECURE_NO_WARNINGS   
 #include "stdafx.h"  
 #include <fstream>  
 #include <iostream>  
 #include <regex>  
 #include <iterator>  
 #include <algorithm>  
 using namespace std;  
 int main() {  
      string seq("tatagcagtcccgctgtgtgtacgacactggcaacatgaggtctttgctaatcttggtagctttg");  
      regex e("(tata)([gatc]*)(tag)");  
      int submatches[] = { 1, 2, 3 };  
      sregex_token_iterator rend;  
      sregex_token_iterator a(seq.begin(), seq.end(), e, submatches);  
      while (a != rend) std::cout << " [" << *a++ << "]";  
      getchar();  
      return 0;  
 }  

Are you being tracked by Facebook?

One way to find out whether the websites you are visiting has facebook tracker is to install Facebook pixel extension on your Google Chrome browser

https://chrome.google.com/webstore/detail/facebook-pixel-helper/fdgfkebogiimcoedlicjlajpkdmockpc?hl=en

You can also see it by examining your network traffic using the developer tool on your browser

String.Compare is a better method to compare strings than String.Equal

String.Compare is a better method to compare strings than String.Equal

Below example illustrates how String.Compare handles nulls better than String.Equal


    class Program
    {
        static void Main(string[] args)
        {
            string A = "Hello World";
            string B = "Hello World";
            string C = null;

            if (String.Compare(B, A) == 0) { Console.WriteLine("A equals B"); }
            if (String.Compare(C, A) == 0) { Console.WriteLine("A equals C"); }
            if (B.Equals(A)) { Console.WriteLine("A equals B"); }
            try
            {
                if (C.Equals(A)) { Console.WriteLine("A equals C"); }
            }
            catch (Exception e)
            {
                Console.Write(e.Message);
            }

            Console.ReadKey();
        }
    }

Anonymous function

 class Program  
   {  
     static void Main(string[] args)  
     {  
       Func<int, int> func1 = x => x + 1;  
       Func<int, int> func2 = x => { return x + 1; };  
       Func<int, int> func3 = (int x) => x + 1;  
       Func<int, int> func4 = (int x) => { return x + 1; };  
       Func<int, int, int> func5 = (x, y) => x * y;  
       Action func6 = () => Console.WriteLine();  
       Func<int, int> func7 = delegate (int x) { return x + 1; };  
       Func<int> func8 = delegate { return 1 + 1; };  
       Console.WriteLine(func1.Invoke(1));  
       Console.WriteLine(func2.Invoke(1));  
       Console.WriteLine(func3.Invoke(1));  
       Console.WriteLine(func4.Invoke(1));  
       Console.WriteLine(func5.Invoke(2, 2));  
       func6.Invoke();  
       Console.WriteLine(func7.Invoke(1));  
       Console.WriteLine(func8.Invoke());  
       Console.ReadLine();  
     }  

Basic Dependency Injection control

I found a simple Inversion Controller on https://timross.wordpress.com/2010/01/21/creating-a-simple-ioc-container

   

public interface IContainer  
   {  
     void Register<TTypeToResolve, TConcrete>();  
     void Register<TTypeToResolve, TConcrete>(LifeCycle lifeCycle);  
     TTypeToResolve Resolve<TTypeToResolve>();  
     object Resolve(Type typeToResolve);  
   }  
   public enum LifeCycle   
   {   
    Singleton,   
    Transient   
   }   
   public class RegisteredObject  
   {  
     public RegisteredObject(Type typeToResolve, Type concreteType, LifeCycle lifeCycle)  
     {  
       TypeToResolve = typeToResolve;  
       ConcreteType = concreteType;  
       LifeCycle = lifeCycle;  
     }  
     public Type TypeToResolve { get; private set; }  
     public Type ConcreteType { get; private set; }  
     public object Instance { get; private set; }  
     public LifeCycle LifeCycle { get; private set; }  
     public void CreateInstance(params object[] args)  
     {  
       this.Instance = Activator.CreateInstance(this.ConcreteType, args);  
     }  
   }  
   public class SimpleIocContainer : IContainer  
   {  
     private readonly IList<RegisteredObject> registeredObjects = new List<RegisteredObject>();  
     public void Register<TTypeToResolve, TConcrete>()  
     {  
       Register<TTypeToResolve, TConcrete>(LifeCycle.Singleton);  
     }  
     public void Register<TTypeToResolve, TConcrete>(LifeCycle lifeCycle)  
     {  
       registeredObjects.Add(new RegisteredObject(typeof (TTypeToResolve), typeof (TConcrete), lifeCycle));  
     }  
     public TTypeToResolve Resolve<TTypeToResolve>()  
     {  
       return (TTypeToResolve) ResolveObject(typeof (TTypeToResolve));  
     }  
     public object Resolve(Type typeToResolve)  
     {  
       return ResolveObject(typeToResolve);  
     }  
     private object ResolveObject(Type typeToResolve)  
     {  
       var registeredObject = registeredObjects.FirstOrDefault(o => o.TypeToResolve == typeToResolve);  
       if (registeredObject == null)  
       {  
         throw new TypeNotRegisteredException(string.Format(  
           "The type {0} has not been registered", typeToResolve.Name));  
       }  
       return GetInstance(registeredObject);  
     }  
     private object GetInstance(RegisteredObject registeredObject)  
     {  
       if (registeredObject.Instance == null ||   
         registeredObject.LifeCycle == LifeCycle.Transient)  
       {  
         var parameters = ResolveConstructorParameters(registeredObject);  
         registeredObject.CreateInstance(parameters.ToArray());  
       }  
       return registeredObject.Instance;  
     }  
     private IEnumerable<object> ResolveConstructorParameters(RegisteredObject registeredObject)  
     {  
       var constructorInfo = registeredObject.ConcreteType.GetConstructors().First();  
       foreach (var parameter in constructorInfo.GetParameters())  
       {  
         yield return ResolveObject(parameter.ParameterType);  
       }  
     }  
   }  
   public class TypeNotRegisteredException : Exception  
   {  
     public TypeNotRegisteredException(string message)  
       : base(message)  
     {  
     }  
   }