There's one of two conclusions that can be drawn: 1) They tried to improve on the previous study by making a biased study. (The phrase refers to their own study) 2) They tried to improve on a previous biased study. (The phrase refers to the previous study they are comparing and contrasting their own with).

Rob Philpott wrote:

My God, are you for real? Of course I saw the point, yes very good and I'm sure what you've written will be up to the same intellectual standard as your last post - hence I can't be bothered to read it.

Aww. And I even included a tl;dr just for you. :)

Rob Philpott wrote:

You can't turn off a wheel, durrh....

Accurate, and completely missing the point.
The wheel allowed people to do far more work for the same amount of effort. It revolutionized technology and how we lived. The internet allows people to find almost any information known to any human being. It is a multiplier for intellect, in the same way as the wheel is a multiplier for muscle. In addition, communication can take place across the entire globe, and have a permanency of at least a few years, often without the need for storing hundreds of paper documents per person.
It sounds like in the course of exploring the internet, you have discovered human social activity you find disagreeable. How you managed to avoid human social activity you find grossly disagreeable throughout elementary, middle school (if it was not subsumed into elementary or high school), high school and possibly college, university or other higher education, is completely beyond me. Or perhaps you've just never learned how to deal civily with people you dislike. But somehow, that people can do things, and have a right to do things, you dislike seems to have come as a shock, horror and surprise to you.
I have a few human social activities I find disagreeable, myself. They include acting like a spoiled child, and being an internet tough guy.
tl;dr - Welcome to the real world. Population: 7 billion...And you.

It's turned everyone into total wimps who can't even pull a sledge.

Keith Barrow wrote:

I suggest you take both these points with the owners of the site.
 
I was just impressed it works the way it does.

I think we should all just take clearly nonsense posts as nonsense, and let anyone who actually means such things, argue that platform themselves.

Terrible. It only plays pre-recorded music. What kind of accordion is this???

Legos are awesome.

Func is only one thing that could be placed in T. A Queue would be equally qualified, as it has a candidate for calling that results in T.

Implicitly storing anything that returns T when "called", in T.

I apologize if you did read this particular post, but it sounds like you didn't, so I'm reposting it. Valid in current paradigm:

var a = 5.5;

Invalid in current paradigm, but valid if paradigm theoretically adopted by C#:

a = new func(delegate() { return 5.5; });

Using a theoretical library of additional functions, both are valid:

DTBase a = (DTVar)5.5;
a = new DTFunc(delegate() { return 5.5; });

The key point is that, instead of being a specific type of variable, "a" is now defined by what you get when you call it. If you're wondering what use being able to type variables by what they return when "called" is, a few suggested thoughts are:

Dictionary> formulasForGame; // Functions, equations, single variables and file reads.

List> urlRetrieval; // Retrieves urls from various places and sources. Optionally, a list of DTArgs.

List> chatRelays; // A set of functions that relay text strings for chat according to the specific sending needs of each specific receiver and sender.

And any other situation where you want a generic, quick way to access data by type, not implementation. That is to say, counting double and Func(double) as separate implementations, but the same type. Thank you for your patience and interest. :)

And here is a heavily-commented "Guess My Number" game using this paradigm (granted, it's not runnable without the classes, but it is heavily-commented. Should I release that code? I've no idea if anyone is the least bit intruiged):

// A simple "Guess my number" program.

        // The length of the number to guess.
        DTVar length = 7;
        // A starting phrase.
        Console.WriteLine("Guess my Number, a {0}-digit number.", length);
        // True if or when the player guesses entirely correctly.
        DTVar allCorrect = false;
        // A function that matches the output of two DTArgs arguments,
        // and returns a string with X's in all locations where they don't match.
        DTFunc matchingF = new DTFunc(
            (a, b) =>
            {
                // Our return string.
                string r = "";
                // If our first DTArgs has values remaining,
                while (a.Count > 0)
                {
                    // We can call a DTArgs to return the next argument,
                    // or we can convert it.
                    // As DTBase works on the principle that
                    // the thing is what it returns when called,
                    // the conversion can be implicit.
                    // A DTArgs is an argument queue, essentially.
                    char a1 = a;
                    char b1 = b.Call;

                    // If the two characters match, add that character to the string.
                    // if they don't match, add 'X' to the string.
                    r += (a1 == b1 ? a1 : 'X');
                }
                return r;
            }
        );
        // A function to generate a new "phone number".
        DTBase numberF = new DTFunc(
            delegate()
            {
                // Stores "length" number of random integers from 0 to 9 in a string.
                string r = "";
                // "length" may be a DTVar, but because the use is unambiguous,
                // it can use implicit conversion.
                for (int t = 0; t < length; ++t) r += Rand.Next(10);
                // Returns the string "phone number".
                return r;
            }
        );

Valid in current paradigm:

var a = 5.5;

Invalid in current paradigm, but valid if paradigm theoretically adopted by C#:

a = new func(delegate() { return 5.5; });

Using a theoretical library of additional functions, both are valid:

DTBase a = (DTVar)5.5;
a = new DTFunc(delegate() { return 5.5; });

The key point is that, instead of being a specific type of variable, "a" is now defined by what you get when you call it.

Essentially? Adds the numbers 0 to 10 to the functions' arguments. The function then iterates through those arguments and constructs a comma-separated string. "Call" is a general property that returns "Whatever it is the object does/is". In the case of the function, it calls the function. In the case of DTArgs, it dequeues the next argument. In comment-o-vision:

        // So, create a new function taking DTArgs as input,
        // which is in short a queue of doubles (or anything else we want)
        // The first type, in this case "double", is the type used by
        // the function's internal DTArgs.
        DTFunc f = new DTFunc(
            a =>
            {
                // The function body.
                string r = "";
                // While our DTArgs 'a' has values,
                while (a.Count > 0)
                {
                    // Add the next argument to the string, followed by a comma.
                    // a.Call dequeues and returns the next argument.
                    r += a.Call + ", ";
                }
                // Chop off the last comma.
                return r.Length > 0 ? r.Substring(0, r.Length - 2) : r;
            }
        );

        // The function needs arguments,
        for (int i = 0; i <= 10; ++i)
            // So add them. Granted, setting a property is not standard.
            // But, this code is in my "StrangeTest" project.
            // .Args is a property accessor to the functions' DTArgs.
            f.Args.Add = i;

        // Call the function and write the output to the console.
        Console.WriteLine(f.Call);

I have no idea how well I'm explaining things (which tends to make my explanations rather...Bad), but hopefully I've cleared up at least a little confusion. :)

For the amusement and edification of any readers - What may be the first actual DynamicTyped program (if someone else didn't yoink the idea first) Provided simply to provide actual code, it accepts a sequence of numbers and outputs a formatted string:

DTFunc f = new DTFunc(
a =>
{
string r = "";
while (a.Count > 0)
{
r += a.Call + ", ";
}
return r.Length > 0 ? r.Substring(0, r.Length - 2) : r;
}
);

        for (int i = 0; i <= 10; ++i)
            f.Args.Add = i;

        Console.WriteLine(f.Call);

Output: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 Now, if I change its arg type to DTBase(double), I could feed all kinds of things into there - Variables, equations, dice rolls, other functions, file reads (not currently, but potentially)...So long as they all returned a double when called.

Currently? Invalid in current state of things:

double a = new Func(delegate() { 2 + 2; });

Granted, a very simple example, but it helps lay the groundwork for the second example. Valid in my Dynamic-Typed paradigm:

DTBase a = new DTFunc(delegate() { 2 + 2; });
Console.WriteLine(a.Call); // Output 4
a = (DTVar)5; // Conversion needed because DTBase is an abstract class.
Console.WriteLine(a.Call); // Output 5
// Equivalent of "1 + 1 = X", where DTEquation calculates "x".
DTBase a = new DTEquation((DTVar)1, new DTOperand[] { new DTOperand(MathOp.Add, (DTVar)1) });
Console.WriteLine(a.Call); // output 2

And in that equation, I could have put any type derived from DTBase(double), including functions, dice rolls, or, yes, other equations. So not *quite* the current state of affairs. :)

In my meanderings through weird code ideas, I wrote down some simple classes in C# based on the idea of "What if variables were typed based on what they returned when called, using that as what they are." So, for example, an equation that returns a double "is" a double (or derived from DTBase(double)); a DTFunc(string) that concatenates a string based on relevant factors "is" a string (or derived from DTBase(string)) and, of course, a DTVar(int) contains and "is" an integer. (Parenthesis substituted for angle brackets) Being as this website is about code and being that I wrote this in C#, I decided to see what other programming netizens might think of this idea, as well as the rather present idea that someone may have thought of this first. Thanks.

modified on Friday, August 26, 2011 9:16 PM

My Snark Detector is going off.

You've all missed the obvious choice. I don't die until the song is over, right? "This is the song that never ends, yes, it goes on and on my friends, some people started singing it, not quite knowing what it was, now they'll keep on singing forever because, this is the song that never ends,..." Yes, this is an actual song, recorded and performed. Also, it's an excellent way to annoy people. Such as, for example, executioners.