While this has been informally known for a long time – and a few schools have taken steps to address it by offering alternatives — but I think this is the first time that it’s been really researched to confirm. I hope this will help. The commends under the original post will be therapy for anybody who was ever faced with standardized testing issues or who stayed away from completion because of them, particularly the GRE.

While this has been
[read full article]

So glad China’s making use of mathematical morphology for their lunar soil experiments. What I love about mathematical morphology is that it’s the only math-y thing I -really- kind of understand, besides computing/information theory – so even though I still don’t want to try to read the formulas, I know what they’re talking about in the surrounding text (at a very basic level anyway) https://www.mdpi.com/2072-4292/11/5/524/htm

So glad China’s making
[read full article]

// Distributed memory task parallel hello world /* This program shows how to use Chapel’s task parallelism and locality features to create a concurrent “Hello, world” program that spans distributed memory `locales` (compute nodes) as well as (optionally) the processing units (cores) within each locale. The number of locales on which to run is specified on the executable’s command line using the `-nl` or `–numLocales` flag (e.g., “./hello -nl 64“). */ // // The following `config const` specifies whether or not the locale // name should be printed (for ease-of-testing purposes); the default // can be overridden on the execution command line (e.g., // “–printLocaleName=false“). // config const printLocaleName = true; // // This one specifies the number of tasks to use per locale: // config const tasksPerLocale = 1; // // Use a `coforall-loop` to create a distinct task per locale on which // the program is executing. Here, we’re iterating over the built-in // `Locales` array which stores an array of locale values // corresponding 1:1 with the system’s compute nodes on which the // program is executing. Thus, each iteration corresponds to one of // the locales, represented by the loop index variable `loc`. // coforall loc in Locales { // // Migrate each task to its corresponding locale, `loc`. This is done // using an `’on’-clause`, which moves execution of the current task // to the locale corresponding to the expression following it. // on loc { // // Now use a second coforall-loop to create a number of tasks // corresponding to the `tasksPerLocale` configuration constant. // Since this loop body doesn’t contain any on-clauses, all tasks will // remain local to the current locale. // coforall tid in 0..#tasksPerLocale { // // Start building up the message to print using a string // variable, `message`. // var message = “Hello, world! (from “; // // If we’re running more than one task per locale, specialize the // message based on the task ID. // if (tasksPerLocale > 1) then message += “task ” + tid:string + ” of ” + tasksPerLocale:string + ” on “; // // Specialize the message based on the locale on which this task is // running: // // * `here` refers to the locale on which this task is running (same as `loc`) // * `.id` queries its unique ID in 0..`numLocales`-1 // * `.name` queries its name (similar to UNIX “hostname“) // * `numLocales` refers to the number of locales (as specified by -nl) // message += “locale ” + here.id:string + ” of ” + numLocales:string; if printLocaleName then message += ” named ” + loc.name; // // Terminate the message // message += “)”; // // Print out the message. Since each message is being printed by a // distinct task, they may appear in an arbitrary order. // writeln(message); } } } // // For further examples of using task parallelism, refer to // :ref:`examples/primers/taskParallel.chpl `. // // For further examples of using locales and on-clauses, refer to // :ref:`examples/primers/locales.chpl `. //

// Distributed memory task [read full article]


Oh semiotics can get you there but, much like binary in computing, you can’t stop at a base level but must approach in a bottom up / top down simultaneously. Pierce’s Theory of Signs acts as a top-down hierarchical framework from which to then build up from primitives. But the theory of signs along is not enough to build a system, much as how boolean logic is a top-down framework upon a dual of 0/1 which can be built up from but is not enough in itself to do much. So inbetween the two you have subsystems.

Oh semiotics can get [read full article]


There’s a lovely reddit group where people post images of their “retrobattlestations” – which is what I guess they call resurrected old computers and equipment – or even simply old pictures of old equipment. I’m enjoying going through image after image of people proudly posting their various victories. https://www.reddit.com/r/retrobattlestations/ This made me smile because I’d never seen it before in my life and I thought I’d seen everything.

There’s a lovely reddit

[read full article]