Learning to learn

On pages 215 and 216 of Understanding by Design, Grant Wiggins and Jay McTighe write:

Here we consider an often overlooked aspect of instructional design—the need to help students self-monitor, self-assess, and self-adjust their work, individually and collectively, as the work progresses. Facet 6 is self-understanding, arguably the most important facet of understanding for lifelong learning. Central to self-understanding is an honest self-assessment, based on increasing clarity about what we do understand and what we don't; what we have accomplished and what remains to be done. The most successful people in life not only have this capacity, they have learned to do so in the most timely and effective ways possible: They self-monitor and self-adjust as needed. They proactively consider what is working, what isn't, and what might be done better as they do it.

With a few years of computing experience under my belt, I'm somewhat aware of my abilities as, say, a computer programmer. I'm becoming increasingly aware of just how unskilled I am as a teacher. But I think I'm simultaneously gaining skills (I'm certainly gaining experience), and I'm holding onto the hope that the rate at which my teaching skills are increasing will someday overtake the rate at which I'm becoming aware of my need to improve.

In "The Profession of IT: Learning to Learn" (starting on page 33 of the December 2016 issue of Communications of the ACM), Peter J. Denning and Gloria Flores write:

Learning-to-learn is a disposition of openness to learning in a domain. If we are not open to learning, we will not learn. . . .

During debriefings, we assist team members to discover what holds them back from asking for help. Their hidden assessments are mostly variations of these five:

• It is important to be competent.
• It is important to be efficient and avoid waste.
• It is important to be independent and self-reliant.
• It is important to be useful.
• It is important to be useful at all times.

In each case, they judge themselves to be incapable of doing these important things. Helping them discover these assessments and then examine the standards that they are holding themselves to is a big step forward in enabling them to develop the skill of learning to learn. . . .

All teams must deal with risk and uncertainty. To be an effective learner in such situations, you must learn two things: first to identify the moods that you find yourself in and, second, to shift into moods that open you to learning. Tables 2 and 3 give examples of common productive and unproductive moods for learning. You can recognize a mood from the assessments you see yourself making about the world around you. For example, if you are experiencing awe and eagerness about what is going on, you are in a mood of wonder. If you see no possibilities for moving forward, you are in a mood of resignation.

The navigational skill of identifying and shifting moods follows the Dreyfus progression just like any other skill development. The beginner learns the names of the moods and the conversations that characterize each one. The advanced beginner recognizes moods more easily and can shift some moods. The competent navigator readily identifies unproductive moods and can usually shift to productive moods alone or with assistance.

Shifting moods requires reflection and practice because you may have to unlearn some habits that you formed for coping with different situations. We have found that asking four questions and reflecting on their answers can open the door to shifting moods. We recommend that you engage these four questions with the help of a teacher or teammate. Although you can do this on your own, we have found that a different observer can help you uncover your hidden assessments, standards, and habits faster.

• What are my prevailing moods and assessments in the situation?
• What standards do I have that provoke these assessments?
• What habits do I have that keep me conforming to the standards?
• Why is reaching my learning objective important to me? What will I be able to do if I persevere?

In this investigation, it is important to notice that moods are different from emotions. Emotions are "foreground" occurrences that we feel as sensations such as anger at an insult or joy at a child's smile. Moods are "background"—they are more like an atmosphere, saturated by vapors of our history and experiences, in which things and possibilities show up in our situation. We can almost always identify the event that triggered an emotion, but we seldom notice our moods. They are automatic assessments that open or close possibilities for us outside of our awareness.

Sometimes moods are temporary and can shift easily. For example, you can be in a mood of resignation (no possibilities are visible) and a parent, teacher, or manager can show you a new possibility that breaks the mood. Sometimes a prevailing mood will yield when you discover a hidden standard and determine to change it. However, some moods are deeply ingrained habitual dispositions that lead you into actions you do not intend. You have adopted a set of personal practices that keep you in conformity with your hidden standards. If you try to violate a practice, you feel extremely uncomfortable and you do not even know why. To shift the long-term mood you will have to train yourself into new practices. This may take time.

See also: UNSKILLED AND UNAWARE OF IT

Strings are in disarray!

Disappointed with his performance, Ursula has replaced Flotsam, the moray eel minion, with Floatsam, the array eel minion. Floatsam's mission, dare he choose to reject it, is to restore order in and around Atlantica.

Help Floatsam succeed by supplying the code needed to make the following bubbleSort method work.

Use the buttons below to select either the Java or JavaScript version of the code.

public class Floats {
  public static boolean areInOrder(float a, float b) {
    return a >= b;
  }
  public static void swap(float[] array, int i, int j) {
  }
  public static float[] bubbleSort(float[] array) {
    boolean doAgain = true;
    int count = array.length;
    int i;
    int j;
    while (doAgain) {
      doAgain = false; // tentative
      for (i = 0; i < count - 1; i++) {
        j = i + 1;
        if (!Floats.areInOrder(array[i], array[j])) {
          doAgain = true;
          Floats.swap(array, i, j);
        }
      }
    }
    return array;
  }
}
class Convert {
  public static float[] toArrayOfFloats(String[] array) {
    int i = array.length;
    float[] arrayOfFloats = new float[i];
    while (--i >= 0) {
      arrayOfFloats[i] = Float.valueOf(array[i]);
    }
    return arrayOfFloats;
  }
  public static String toString(float[] array) {
    String s = "";
    int n = array.length;
    for (int i = 0; i < n; i++) {
      if (i > 0) {
        s += " ";
      }
      s += array[i];
    }
    return s;
  }
}
class BubbleSort {
  public static float[] work(String[] strings) {
    float[] array = Convert.toArrayOfFloats(strings);
    return Floats.bubbleSort(array);
  }
  public static void main(String[] args) {
    float[] sortedArray = BubbleSort.work(args);
    String s = Convert.toString(sortedArray);
    System.out.println(s);
  }
}

Floats = {
  areInOrder: function(a, b) {
    return a >= b;
  },
  swap: function(array, i, j) {
  },
  bubbleSort: function(array) {
    var doAgain = true;
    var count = array.length;
    var i;
    var j;
    while (doAgain) {
      doAgain = false; // tentative
      for (i = 0; i < count - 1; i++) {
        j = i + 1;
        if (!Floats.areInOrder(array[i], array[j])) {
          doAgain = true;
          Floats.swap(array, i, j);
        }
      }
    }
    return array;
  }
}
Convert = {
  toArrayOfFloats: function(array) {
    var i = array.length;
    var arrayOfFloats = [];
    while (--i >= 0) {
      arrayOfFloats[i] = parseFloat(array[i]);
    }
    return arrayOfFloats;
  },
  toString: function(array) {
    s = "";
    var n = array.length;
    for (var i = 0; i < n; i++) {
      if (i > 0) {
        s += ", ";
      }
      s += array[i];
    }
    return s;
  }
}
BubbleSort = {
  work: function(strings) {
    array = Convert.toArrayOfFloats(strings);
    return Floats.bubbleSort(array);
  },
  main: function(args) {
    var sortedArray = BubbleSort.work(args);
    var s = Convert.toString(sortedArray);
    console.log(s);    
  }
}

floopy function

var s = '';

floop = function(s) {
  var ss = '',
  i = s.length,
  j = 0;

  while () {

    ss = s[i] + ss;
    if (++j >= s.length) {
      break;
    }
  }
  return ss.toString();
}
var r = floop(s);
console.log(r);
alert(r);

The Josephus Problem

On page 8 of Concrete Mathematics: A Foundation for Computer Science, the authors (Graham, Knuth and Patashnik) present the Josephus problem as follows:

Our final introductory example is a variant of an ancient problem named for Flavius Josephus, a famous historian of the first century. Legend has it that Josephus wouldn't have lived to become famous without his mathematical talents. During the Jewish-Roman war, he was among a band of 41 Jewish rebels trapped in a cave by the Romans. Preferring suicide to capture, the rebels decided to form a circle and, proceeding around it, to kill every third remaining person until no one was left. But Josephus, along with an unindicted co-conspirator, wanted none of this suicide nonsense; so he quickly calculated where he and his friend should stand in the vicious circle.

In our variation, we start with n people numbered 1 to n around a circle, and we eliminate every second remaining person until only one survives.

A note in the margin reads:

(Ahrens [5, vol. 2] and Herstein and Kaplansky [156] discuss the interesting history of this problem. Josephus himself [166] is a bit vague.)

Last but not least, the other note in the margin says:

... thereby saving his tale for us to hear.

---

Passover Count:
Rebel Count:
Vicous Circle:
Execution Order:
Josephus Number:

Last Command

Tools

One Bit Cycle Shift Left

	decimal	binary
n:
OBCSL:

Logical and Bitwise Operators

a: ← Operand (number, true or false)

b: ← Operand (number, true or false)

c:

← Operand examples

Exercise

• For each example pair of operands, study the result of "passing" the operands to the corresponding logical or bitwise operators.
• Try other pairs of operands.
• Attempt to empirically determine the rules associated with each logical and bitwise operator.
• For each operator, after you have formed a hypothesis about how the operator works, compare your hypothesis with documentation (print or online) for that operator. For example:
  • MDN: Logical Operators
  • MDN: Bitwise Operators
• Formulate a question about something you don't understand related to a logical or bitwise operator, and find an answer to your question. How much confidence do you have in the answer? Why?
• Optional: Compare the logical and bitwise operators for JavaScript with those for Java.
  • Does Java have the same logical and bitwise operators that JavaScript does?
  • Are there any differences between the way the JavaScript logical and bitwise operators work compared to the corresponding Java ones?

Proof

What's a method for ascertaining the truth?

Professor Leighton was ahead of his time when in 2010, during his lecture:

Lec 1: MIT 6.042J Mathematics for Computer Science, Fall 2010

@5:30 he said:

. . . another one is the word of your boss. Whatever the boss says is right. Often in business the customer is always right. That's the truth--whatever the customer says. Alright. You know, with Donald Trump as your boss, you better agree or you're fired. Right? Umm... Often in class, if the professor says it, it is true. . . .