randInt(1,1000) -> A

I will leave the rest of the program writing to you. You’ll use Lbl, if, Input, math tests (>, <) and Disp.

I originally got the idea for a number guessing program when I was 12. I got it from the book, Basic Computer Games. This book made quite an impression upon me, so it is a pleasure to pass along a snippet (click on the image below to see page 75):

The second task for the student is to think of the best way to guess numbers. For example, consider that I am thinking of a number from 1 to 1000, and I ask you to guess that number (and I will tell you if you are too high or too low). Two bad ways to go about guessing would be to begin at one and count up to 1000 till you got it, or to begin and 1000 and count down. There must be a better way. Find that way. And then come up with a statement that will tell me the most number of guesses it would take for a person to figure out the secret number.

Do the same thing as if the number to be guessed is between 1 and 10.

Then do it again for a number between 1 and 100. Then 1 and 1000. Can you find a general pattern that will tell you the maximum number of guesses it would take to find the hidden number for any range?

Bonus Assignment: This following line of thinking was not covered in our last class. But consider what it would be like to play the game of Guess in reverse… bear with me, and I’ll try to explain. Imagine that instead of randomly picking a number, the computer randomly picks “too high” or “too low” at each guess. That is, the computer itself does not know the secret number, but discovers it with the guesser. Can any number be written as a sequence of “too high” and “too low” statements? Don’t worry if this Bonus Assignment makes no sense. But if you follow the gist, have fun thinking about it. And welcome to the world of open-ended questions.

For the source code, click here.

In the beginning, what I wrote on Twitter was a simple index into my latest thoughts. To the outside observer (and especially to the unsympathetic reader) the appearance of my thoughts appeared thoughtless. I was accused of thoughtless thinking. But I imagine that thinking, for many of us, would externally appear to be an undirected or thoughtless activity, and maybe my thinking is. Regardless, thinking is a mostly private affair, and when it was opened up to the world around me, it came off as a collection of unrelated and even crass ciphers. As I began to spread my thoughts, the offense spread.

I never thought that my Twitter account was just for me. But I acted like it was, and so my thoughts were escaping my brain and making it into the wild, but I was thinking like they were still in my head.

My rational was simple. I was writing sentences for the benefit of wanting to recall them later — they were for me to remember (and I still want that Twitter-benefit). But now I am using Twitter as my memories according to this new dictum: Not everything I want to remember do I want to share.

Twitter has evolved for me. First it was a noteworthy little place on the web, and I had an account. Then I tied it to my cell phone and I could easily send messages and track ideas. Then I tied it to my Facebook and I could update my Facebook from my cell phone. I had lots of friends and social media was good to me. But then I wrote more things. And then Twitter was not so good. Soon, my social media was antisocial. So I deleted my Facebook, kicked everyone off of my Twitter account, pulled everything back, and made all my ideas hidden and private.

My Twitter-Cards are now held close; every madly-scribbled thought is a note to me, or a memo to myself. These sentences live in my auxiliary storage–Twitter is an extension of my memory. But Twitter is different than normal memories; I can search these auxiliary sentences and go back to my thoughts and deliberately pick up where I left off in my thinking. My Twitter account is not just an index into my latest thoughts, but is a placeholder for a whole history of thoughts.

My previous mistake was that I was thinking too loudly.

Now I am thinking quietly. I am not claiming to be profound (probably I need to encrypt my thoughts just to spare the world). In fact, just as my thoughts are locked up behind my skull, my Twitter-Thoughts now live behind a mathematical barrier I thought up.

That’s the setup for the cryptography code I am about to show you. Now that my Twitter is closed, I thought: What if some of these thoughts escape? I write some pretty intense things that aren’t safe to share. I still want to use up my 140 character space, but I want some encryption.

I can now encrypt my Twitter comments. I wrote a simple encryption, nothing fancy, just enough to block the casual observer (especially if I leave my Twitter account up on a computer).

Here is the code for that (I had to sacrifice one character to pull this off — my encrypted tweets are thus limited to 139 characters, with one character marking the fact that it is encrypted):

/// <summary>
    /// pw is optional.  If not supplied, we just return the plain text passed in.
    /// Encrypt the plain text, then add a "*" to the end of the string (indicating a encrypted string)
    /// </summary>
    /// <param name="plain"></param>
    /// <param name="pw"></param>
    /// <returns></returns>
    public static string enc(string plain, string pw)
    {
        const byte space = 32;
        const int elements = 126 - space;
        string res = plain;
        if (pw != null && pw != string.Empty)
        {
            byte[] key = Encoding.ASCII.GetBytes(pw);
            byte[] data = Encoding.ASCII.GetBytes(plain);

            int k = 0;
            for (int i = 0; i < data.Length; i++)
            {
                int e = data[i] - space;
                e = (e + key[k]) % elements;
                data[i] = Convert.ToByte(e);
                data[i] += space;
                k++;
                if (k >= key.Length)
                    k = 0;
            }

            res = Encoding.ASCII.GetString(data) + "*";
        }
        return res;
    }
    /// <summary>
    /// Any string that ends in '*' is treated as encrypted.
    /// But we only decrypt it if you pass in a password (and, FYI, the '*' is not part of the encryption).
    /// </summary>
    /// <param name="enc"></param>
    /// <param name="pw"></param>
    /// <returns></returns>
    public static string dec(string enc, string pw)
    {
        const byte space = 32;
        const int elements = 126 - space;
        string res = enc;
        if (pw != null && pw != string.Empty)
        {
            if (enc[enc.Length - 1] == '*')
            {
                byte[] key = Encoding.ASCII.GetBytes(pw);
                byte[] data = Encoding.ASCII.GetBytes(enc.Substring(0, enc.Length - 1));
                int k = 0;
                for (int i = 0; i < data.Length; i++)
                {
                    int d = data[i] - space;
                    d = d - key[k];
                    while (d < 0)
                        d += elements;
                    d = d % elements;
                    d += space;
                    data[i] = (byte)d;
                    k++;
                    if (k >= key.Length)
                        k = 0;
                }
                res = Encoding.UTF8.GetString(data);
            }
        }
        return res;
    }

And here you see how these Twitter messages look when encoded. I map everything to the ASCII printable character set. That’s important to know. I don’t have to worry about hitting those reserved Twitter characters. I also have it so that the encrypted text is as long as the plain text. Except for the one character that I sacrifice in order to notate that a message is encrypted (which I don’t have to do, but I have my reasons), I get to keep using Twitter as normal.

If you got this far, you may want to use this encryption for yourself. In that case, you have some options. The fastest and easiest option is to use my stand-alone crypt program [see my later article for download instructions].

Optionally, I have my own Twitter program I wrote. To use the encryption code I have offered here, you need to use this or some other custom Twitter software. You can write your own (and add the above code to it), or you can use my free MicroSpeak140. Click the following link to read more about MicroSpeak140 (where you can also get all the code).

Now think. And with encrypted Twitter, you can think quietly like you have always done.

About the Method and the Encryption Strength
Someone who is acquainted with cryptographic methods may detect a weakness of what I have implemented. I will address that below, and I will give a fairly substantial defense. Yet, even if my defense is weak and my method is poor, let me set the context: I’m not trying to protect Fort Knox. My brain is not a vault of treasures. I am not trying to encrypt government secrets. I just want a little bit of bone structure to encase some sensitive tissues. My encryption scheme fits the bill.

Mine is a Vigenere Cipher (which, as you will read, is a improvement upon the older Caesar Cipher). The Vigenere method meets my five chief requirements: 1. Most obviously, I want to change the plain text (that is, I want to obscure the original message), 2. I want to use a password scheme so that each use gets different results based on the password, 3. I want to be able to use the same password to recover the plain text, 4. I want to obscure the frequencies of the English letters in the plain text, and finally, 5. As important as items 1 through 4, I want the encrypted text length to be the same or less than the length of the plain text (some encryption schemes yield an encrypted text that is longer than the plain text).

Now, we know that a Viegenre cipher is mathematically breakable if the key length is known and if your attacker is the NSA (or is a sufficiently motivated geek who is extremely patient and determined). That is, someone would have to want your memories to try to crack them, and it would require some good effort on their part (the Twitter equivalent to being captured and interrogated).

Ah, but, you can use a password that is the same length as the message you are encoding! After all, with Twitter, we are talking about messages not more than 140 characters long; we have a reasonable shot at picking memorable sentences as pass-phrases. Furthermore, you can use any number of sentences as pass-phrases. That is, you don’t have to use the same password (or pass-phrase) for every single Tweet. And, at this point, using passwords that run the length of your message (which you could database), you have a nearly unbreakable cipher.

But that means if you forget your passwords, you lose your memories (the Twitter equivalent to Alzheimer’s).

If you still want something stronger, you can try an AES and encrypt a string so that it comes out equal length — for more on this subject, look here. I did not take that route as I wasn’t that interested (nor sufficiently motivated), but with OpenSSL, these sorts of things are not so hard.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace RCopy
{
    /// <summary>
    /// Remote Copy a file on an IntraNet.
    /// </summary>
    class RCopy
    {
        /// <summary>
        /// Copy a file starting at position.
        /// </summary>
        /// <param name="fname"></param>
        /// <param name="pos">Where to start copying,</param>
        /// <returns></returns>
        static bool Copy(FileStream fs, FileStream destination, long start, out long howFarWeMadeIt)
        {
            bool ret = true;
            howFarWeMadeIt = start;
            try
            {
                BinaryWriter w = new BinaryWriter(destination);
                BinaryReader r = new BinaryReader(fs);
                long length = r.BaseStream.Length;
                if (length > start)
                {
                    r.BaseStream.Seek(start, SeekOrigin.Begin);
                    Console.WriteLine("rem Starting at " + start + " and going to " + length);
                    while (howFarWeMadeIt < length)
                    {
                        byte[] buffer = new byte[] { 0 };
                        r.BaseStream.Read(buffer, 0, 1);
                        w.BaseStream.Write(buffer, 0, 1);
                        howFarWeMadeIt++;
                    }
                }
                r.Close();
            }
            catch
            {
                ret = false;
            }

            if (fs != null)
                fs.Close();
            return ret;
        }
        static int Main(string[] args)
        {
            if (args.Length < 2 || args.Length > 3)
            {
                Console.WriteLine("rem Usage: RCopy <source> <destination> [pos]");
                Console.WriteLine("rem");
                Console.WriteLine("rem        Remote Copy a source file off an intranet.");
                Console.WriteLine("rem               If your connection times-out while copying, you can call this program many times.");
                Console.WriteLine("rem               This program will pick up copying from the last position.");
                Console.WriteLine("rem               Pass in the position for how far the file copy got before it timed out.");
                Console.WriteLine("rem");
                Console.WriteLine("rem        <destination> will be appended if [pos] is zero or not passed in.");
                Console.WriteLine("rem");
                Console.WriteLine("rem");
                Console.WriteLine("rem        [pos] is a positive integer to start copying at the given offset");
                Console.WriteLine("rem              Default value is zero.");
                Console.WriteLine("rem");
                Console.WriteLine("rem        This program sets RCOPY to -1 if the copy failed;");
                Console.WriteLine("rem        This program sets RCOPY to 0 if it has success;");
                Console.WriteLine("rem        This program sets RCOPY to a positive number if got partially done.");
                Console.WriteLine("rem");
                Console.WriteLine("rem        This program returns an errorlevel as well.");
                Console.WriteLine("rem             errorlevel 0 means the program is done or will not work.");
                Console.WriteLine("rem             errorlevel 1 means the program worked and has more work to do.");
                Console.WriteLine("rem");
                Console.WriteLine("rem");
                Console.WriteLine("rem        This is slow program. It copies one byte at a time. It is not meant for speed.");
                Console.WriteLine("rem        It is meant to work on an unreliable network.");
                Console.WriteLine("rem");
                Console.WriteLine();
                Console.WriteLine("set RCOPY=-1");
                return -1;
            }
            long start = 0;

            if (args.Length == 3)
            {
                try
                {
                    start = Convert.ToInt64(args[2]);
                }
                catch
                {
                    Console.WriteLine("rem Invalid integer value: " + args[2]);
                    Console.WriteLine("set RCOPY=-1");
                    return 0;
                }
            }


            FileStream dest = null;
            try
            {
                if (start == 0)
                    dest = File.Open(args[1], FileMode.Create);
                else
                    dest = File.Open(args[1], FileMode.Append);
            }
            catch
            {
                Console.WriteLine("rem Error: Could not write to " + args[1]);
                Console.WriteLine("set RCOPY=-1");
                return 0;
            }

            FileStream source = null;
            Console.WriteLine("rem Reading " + args[0] + " starting at " + start);
            try
            {
                source = File.Open(args[0], FileMode.Open);
            }
            catch
            {
                Console.WriteLine("rem Could not open " + args[0]);
                Console.WriteLine("set RCOPY=-1");
            }

            long pos = 0;
            while (!Copy(source, dest, start, out pos))
            {
                start = pos;
                bool bail = false;
                try
                {
                    source.Close();
                    source = File.Open(args[0], FileMode.Open);
                }
                catch
                {
                    bail = true;
                }
                if (bail)
                {
                    Console.WriteLine("rem Call this program again: rcopy " + args[0] + " %RCOPY% ");
                    Console.WriteLine("set RCOPY=" + start);
                    dest.Close();
                    return 1;
                }
            }
            try
            {
                source.Close();
                dest.Close();
            }
            catch
            {
                Console.WriteLine("rem Closed files.");
            }
            Console.WriteLine("rem Success");
            Console.WriteLine("set RCOPY=0");

            return 0;
        }
    }
}

The Kansas Highway Patrol identified the victim as Christopher T. Keck, 45, of Gardner, Kan.

The crash occurred about 8:45 a.m. in a northbound lane of Interstate 635 just north of Interstate 70.

Keck was traveling north when his car was hit head-on by a vehicle headed the wrong way on the interstate.

Three useful articles on Cathodic Protection:

http://www.npl.co.uk/upload/pdf/cathodic_protection.pdf
http://www.sescocp.com/tutorial.php
http://www.corrosionsource.com/%28S%28cylzjm45pkvkle45ywzhvn55%29%29/FreeContent/1/Cathodic+Protection

Notice I added customErrors with the value, mode=”Off” and I added a whole section called system.codedom section.

You will also need to configure your project by right clicking on your project, and selecting “Add Deployable Dependencies…” and then check all the boxes in the dialog that follows.

Then, highlight and select all the references in your new _bin_deployableAssemblies and set the properties for all of the to either “Copy always” or “Copy if newer”

Finally, make sure that Global.asax is added to the list of files you can access. This is done under IIS under the Virtual directory you care about (where you installed your web site) or under the web site itself.

In C# this makes all the difference. I realized this morning that I don’t wire-up relationships, but the C# MVC system works on the basis of mere existence.

If a filename with a certain name exists, it is accessed by a controller. In the Data Entity Model, the existence of a table name is mapped to a class name. By existence. I don’t tell the C# system what to associate with what. I just create the item, and its existence makes it alive.

C# MVC programming is programming by existence.

It is also programming by name. When something exists, it must be named (a file name, a class name, a property name, etc.). If it exists, its name is how it relates to the system.

C# MVC programming is programming by existence with right naming.

This is eloquent.

@if (false) {<script type="text/javascript" src="../../Scripts/jquery-1.6.2-vsdoc.js"></script>}

Put this before your jquery include.

If this is what you seek, then let me point you to the TextHighlighterExtensionSetup by Frederic Torres (you can use Visual Studio, Tools->Extension Manager to obtain it, or do the following steps).

Step 1: Install the Iron Python 2.6 or greater (for .NET 4). It was a one or two click install, I didn’t change any settings, it just worked. Try this link: http://ironpython.codeplex.com/releases/view/41236#DownloadId=159515 or get 2.7 here: http://ironpython.codeplex.com/releases/view/62475. If the link is no good, just go to Iron Python, click on the Download menu, and get the latest download.

Step 2: Get and install the .CMD extension itself: http://visualstudiogallery.msdn.microsoft.com/6706b602-6f10-4fd1-8e14-75840f855569 If this link dos not work, go to the Visual Studio Gallery and search for TextHighlighterExtensionSetup (note, there are a few search boxes, make sure to use the one that searches the extensions).

For another useful extension, see also Spell Checker which adds the little red underline to misspelled words in comments. Very nice.