forgot Mac OS X account password

If you have forgot Mac OS X account password then there is a tricky method which let you create a new administrator account on Mac OS X and through that admin account you can reset password of previous account.
So, let’s see how to create an administrator account on Mac while you lost your Mac passwords. This guide written using Mac OS X Snow Leopard.

Creating new Mac OS X account to recover old account

Step 1

Restart system and hold “Cmd + S” keys from keyboard until it shows Terminal.

Step 2

Now type the following commands one after one and press “Enter” button after each command to execute it individually
/sbin/mount -uaw
rm /var/db/.applesetupdone
reboot

Step 3

“Reboot” command will restart the Mac and you will see the “Welcome wizard” after beautiful welcome messages animation.

Follow all the wizard instructions, until you see the following screen to create new account. Fill all entries and hit Continue button.

This will create a new administrator account and automatically log into it.

Reset old user account password

Now you can reset the password of your old Mac OS X account using this new account, here is the process.

Step-4

Click on “Apple icon” and then “System Preferences”

Click on “Account”s icon

Step-5

Here you can see all Mac OS X user accounts are listed, new account “TrickyWays” that we have created and “Susan” the old one that we want to recover.
Click on lock icon to enable prev. account “Susan” and reset its password.

Enter the Password of current user account and hit OK button

Step-6

Now your prev. account is enabled for changes, select that and hit the “Reset Password” button

Enter “New password”, “Password hint” and hit “Reset Password” button to reset account password.

Now log off and log in to your prev. account “Susan” and you can delete the account “TrickyWays” that we have created to recover prev. account “Susan”.

Get and set with C#

You don't need to use set or get. You could write functions named setFoo or getFoo instead of using a property Foo:

class Point {
    double x, y;
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    public double GetX() { return x; }
    public void SetX(double x) { this.x = x; }
    public double GetY() { return y; }
    public void SetY(double y) { this.y = y; }
}

But that's a real pain -- you'd rather write pt.Y = 3; and be able to write things like pt.Y += 5; , instead of pt.SetY(pt.GetY() + 5); .
So instead C# has properties:

class Point {
    double x, y;
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    public double X {
        get { return x; }
        set { x = value; }
    }
    public double Y {
        get { return y; }
        set { y = value; }
    }
}

Inside the setter, the keyword 'value' is the variable containing the value that is getting assigned to the property Y.
The pattern of having properties directly backed by fields is so common that in C# 3, shortcut syntax was added.

class Point {
    public Point(double x, double y) {
        X = x;
        Y = y;
    }
    public double X { get; set; }
    public double Y { get; set; }
}

There are a few reasons to use properties, instead of public fields. One is that properties can be virtual. Another is that you can make the setters for a property private. Another is that properties have a 'special' meaning to things that inspect classes at runtime. There are frameworks for conveniently talking to databases and for reading and writing objects to and from XML and all sorts of other things -- and they automatically look at the object's properties (and not private fields or other things) to see how to do their job.

Free Javascript Obfuscator and Free PHP Obfuscator

Free Javascript Obfuscator

http://www.javascriptobfuscator.com/default.aspx

Free PHP Obfuscator

http://www.pipsomania.com/best_php_obfuscator.do
http://www.mobilefish.com/services/php_obfuscator/php_obfuscator.php

This example calls the ToInt32(String)

This example calls the ToInt32(String) method to convert an input string to an int . The program catches the two most common exceptions that can be thrown by this method, FormatException and OverflowException. If the number can be incremented without overflowing the integer storage location, the program adds 1 to the result and prints the output

static void Main(string[] args)
{
    int numVal = -1;
    bool repeat = true;

    while (repeat == true)
    {
        Console.WriteLine("Enter a number between −2,147,483,648 and +2,147,483,647 (inclusive).");

        string input = Console.ReadLine();

        // ToInt32 can throw FormatException or OverflowException. 
        try
        {
            numVal = Convert.ToInt32(input);
        }
        catch (FormatException e)
        {
            Console.WriteLine("Input string is not a sequence of digits.");
        }
        catch (OverflowException e)
        {
            Console.WriteLine("The number cannot fit in an Int32.");
        }
        finally
        {
            if (numVal < Int32.MaxValue)
            {
                Console.WriteLine("The new value is {0}", numVal + 1);
            }
            else
            {
                Console.WriteLine("numVal cannot be incremented beyond its current value");
            }
        }
        Console.WriteLine("Go again? Y/N");
        string go = Console.ReadLine();
        if (go == "Y" || go == "y")
        {
            repeat = true;
        }
        else
        {
            repeat = false;
        }
    }
    // Keep the console open in debug mode.
    Console.WriteLine("Press any key to exit.");
    Console.ReadKey();    
}
// Sample Output: 
// Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive). 
// 473 
// The new value is 474 
// Go again? Y/N 
// y 
// Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive). 
// 2147483647 
// numVal cannot be incremented beyond its current value 
// Go again? Y/N 
// Y 
// Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive). 
// -1000 
// The new value is -999 
// Go again? Y/N 
// n 
// Press any key to exit.

C# - DataGridView - Confirmation Dialog on Row Delete

            if (!e.Row.IsNewRow)

            {

                DialogResult dialogResult = MessageBox.Show("Do you want to delete ?", "Delete", MessageBoxButtons.YesNo);

                if (dialogResult == DialogResult.Yes)

                {

                }

                else

                {

                    e.Cancel = true;

                }

            }

How to change the height of a combobox from designer view?

Change DrawMode property to OwnerDrawVariable, and then change the ItemHeight property. You may need to change IntegralHeight property to false.

Low Level Language

Machine Code

• A low-level language is one that is close to the fundamentals of the computer's hardware. The lowest-level language is machine code, which is understood directly by the hardware and does not require any interpretation or translation. Machine code consists entirely of strings of binary numbers: the famous zeroes and ones. While it can do anything any other language can do --- indeed, every other language must be translated into machine code by an interpreter --- it is not designed around the needs of the programmer, requires a very close understanding of a computer's processor and devices, and is almost impossible for a human to read.

Assembly Language

• The next-"higher" programming language is assembly language, which is machine code with the instruction codes replaced by more intuitive commands. The command to put a value of 97 into a memory register called AL, for example --- which would in machine code be "10110000 01100001" --- would in assembly language be "MOV AL, 97", still a cryptic command but one much easier to learn. While it is still inefficient to write and requires a programmer to deal directly with her computer's hardware, it is a higher-level language than machine code because it is more abstract: It is closer to the writer.

High Level Language

• Modern programmers write even in assembly language very rarely. Instead, they use one of many different higher-level languages like C, Java or Python, which programs called compilers or interpreters can translate into machine code. These languages remove the programmer from the physical realm of the hardware and into logical abstraction: Rather than moving hexadecimal values around memory registers, the programmer works with variables whose contents can be changed; loops that can be repeated until some condition is met; logical statements like IF, AND, THEN, OR and ELSE; and other tools. These languages are designed around the programmer, attentive to the ways she can be given the most power with the least difficulty.
  

Comparisons

• High-level languages are not so called because they are "better" than low-level languages. Sometimes, the ability to talk more directly to a computer's processor in assembly language or even machine code can solve problems made difficult by the layers of abstraction in a higher-level language. A very high-level language may deal only with a particular operating system, like Microsoft Visual Basic; or with a particular program, like the "macros" in a word processor. These programs are very useful for someone who wants to manipulate Windows or Word without having to know the intricacies of how each works --- but such a language would be of no use to someone trying to write a program of his own, who would need something lower-level. A programmer thus chooses a language based on the job that he needs to do.