Rolandt

I made the mistake of mentioning I was a bit struck by David Wiley’s recent post “How is Open Pedagogy Different?” on Twitter. I should have gone right to the blog because the tweet onslaught from David and Mike Caulfield was a bit off-putting. What started off as a concern, quickly turned into a one-sided tweetstorm that felt like a DdOS attack on my brain. Also, part of what I couldn’t capture on Twitter was the fact I had just come off a day at the OER17 conference in London. In fact, for almost two weeks I was traveling around the UK and Ireland talking about a variety of work happening with domains. Now, I would agree if someone said my work tends towards open: I try and openly blog much of my work, I try and share resources (mostly human), and teach with an eye towards the open web. So, when I read Wiley’s post I referred to above, I was fairly struck (and not in a good way) by this bit:

Open pedagogy is the set of teaching and learning practices only possible or practical in the context of the 5R permissions. Or, to operationalize, open pedagogy is the set of teaching and learning practices only possible or practical when you are using OER.

My simple concern is, when did open become boiled down to a strict set of permissions? Seems to me the conflation of David’s vision of OERs, and a broader communities use of open in less orthodox ways has come to heads—but I’m not sure it needed to. Seems the idea of OERs sat comfortably within open as a broader series of relations and approaches in the field of ed-tech. To be clear, I have no doubt Mike and David can (and have) argued circles around me when it comes to the technicalities of what makes something open, but I do have to wonder about the spirit of such a message. In a moment when fences and lines are being drawn all around the world according to ideologies that other and petty definitions that exclude, why would this seem a good time to start drawing lines around open? Frankly, it seems a bit more like fear mongering. I am not afraid to re-use copyrighted work, in fact I enjoyed it deeply during #ds106, and I have been very clear again and again as to why. I don’t feel like I need permission to intervene with or critique the mediated culture being shoved down my throat. That was one of the pillars (a 106 bullet if you will ) of #ds106. I never really thought of ds106 as a subtle struggle for permissions, but an outright attack on the copyright regime. In fact, in the various forms we taught it—all of which where abusing copyrighted material—we never heard a peep about copyright save the occasional YouTube takedown. Which if anything, was a good reminder of how little permission we do have when it comes to remixing our culture. And if we did get an onslaught of takedowns across the various blogs, I would be far more interested in talking about Fair Use with our students as a defense than becoming the arbiter of permissions. Or even worse, retreating to a textbook.

In the end, I am not too concerned if #ds106 is understood as open pedagogy or not, because as soon as it is a choice between awesome and open, I will choose awesome every time. I am not interested in the strict rules that define open; open is not the ends, it is one means amongst many. But, I do wonder at the push to consolidate the definition beyond OERs into Open Educational Practices. Seems to me there is an attempt to define it in order to start controlling it, and that is often related to resources, grants, etc. Again, I’m not all that concerned personally given I have never depended on grants for my work, but many people do—and strict definitions of open could be perceived as threat to new approaches and ideas.

I think the locking down of open is dangerous. I think it draws lines where they need not be, and it reconsolidates power for those who define it. More than that, the power around open has been pretty focused on a few people for too long, and I count myself amongst them. More and more on this trip in conversations with others, I think we as a field need to do a better job of bringing the next generation of ed-tech folks to the fore, stepping back, and letting them frame what’s next. Even this post shows my harkening back to work I did 6 years ago, I don’t want to have a corner on open or ed-tech, I want something that gets me excited and passionate. OER17 certainly did that, and I crave more. What I see as hardline definitions of what is and is not OER or open need not police the discussion. I would hate for an edict about what is and is not open pedagogy to get in the way of people “coloring outside the lines” of the 5Rs, to appropriate Brian Lamb’s gorgeous turn of phrase from one of this 3 tweets in response to the avalanche.

Now, this may mean we have to move away from the term open because it has effectively been trademarked, and if that’s the case I am fine with that. EDUPUNK was long overdue for a resurgence

I was a fan of MUDs from my earliest introduction to computers. I remember writing to Richard Bartle when I was young asking about the possiblity of accessing MUD1 from New Zealand after having read about it in a magazine. The reply was very positive but unfortunately the cost of 300 baud modem access at international phone rates was prohibitive. It was later in life that my first use of the internet and a shell account on my ISP was to compile and run a MUD client.

The MOO variants of MUDs are particularly interesting as they are multi user, programmable, interactive systems. They're like IRC where users can create objects, rooms and worlds by writing programs within the system. This resulted in systems with interesting programming systems with permission models for different levels of users. Content, including code, was stored in a persistent object database. LambdaMOO was a very popular instance of a MOO.

A while back I stumbled across 3-Move, a multi user networked online text-based programmable environment, by Tony Garnock-Jones. It's a neat system that includes:

• Persistent object-oriented database
• A MOO inspired security model
• Prototype-based object-oriented language
• First-class functions, continuations and preemptive green threads.

There's not much written in the way of documentation on getting it running so this post documents how I got it working. It appears to not be actively developed anymore but it's a nice small system to learn from.

Building

Building 3-move requires cloning the source and running make:

$ git clone https://github.com/tonyg/3-move
$ make
$ ./move/move
move [-t] <dbfilename> [<move-source-code-file> ...]

This produces the move executable which is the virtual machine and a checkpoint-cleanup which is a helper program to clean up database checkpoint files.

The move executable requires a database as an argument. This database stores the state of the persistent world. It's loaded in memory when move is run and can be saved by occasionally checkpointing the system. Optional arguments are move source code files that are compiled and executed.

In the db directory are a number of move source files that contain the code for a multi user virtual environment. The command parser, socket usage, line editor, etc are all written in these move files.

Database

To create an initial database there is a build script that creates a database with the content of the move file. It can be run with:

$ cd db
$ ./build

This creates the database in a file, db, and a symbolic link to the move executable in the current directory for easy execution. All the build script does is run move on files in the right order to build the database. It's equivalent to:

$ ./move db root.move && mv move.checkpoint.000 db
$ ./move db system.move && mv move.checkpoint.000 db
$ ./move db thing.move && mv move.checkpoint.000 db
$ ./move db login.move && mv move.checkpoint.000 db
$ ./move db player.move && mv move.checkpoint.000 db
$ ./move db room.move && mv move.checkpoint.000 db
$ ./move db exit.move && mv move.checkpoint.000 db
$ ./move db note.move && mv move.checkpoint.000 db
$ ./move db program.move && mv move.checkpoint.000 db
$ ./move db registry.move && mv move.checkpoint.000 db

Each run of move creates a new database called move.checkout.000, containing the state of the old database plus any changes made by the move file. This is then renamed back to db and run again on the next file. The end result is a complete database with a default virtual environment.

Running

With the database built the system can be run with:

$ ./move db restart.move

restart.move calls start-listening() to start the socket server accepting connections:

set-realuid(Wizard);
set-effuid(Wizard);

start-listening();

It calls the set-realuid and set-effuid functions to Wizard before calling to ensure that the system can access the default "Wizard" user which has full permissions to call the socket related functions.

start-listening is implemented in login.move. It creates a server socket that accepts connections on port 7777. It can be connected to via telnet, netcat, or similar program:

$ nc 127.0.0.1 7777
        _/      _/    _/_/_/    _/      _/  _/_/_/_/_/  
       _/_/  _/_/  _/      _/    _/  _/    _/       
      _/  _/  _/  _/      _/    _/  _/    _/_/_/        
     _/      _/  _/      _/      _/      _/         
    _/      _/    _/_/_/        _/      _/_/_/_/_/      

3-MOVE Copyright (C) 1997--2009 Tony Garnock-Jones.
This program comes with ABSOLUTELY NO WARRANTY; for details see
http://homepages.kcbbs.gen.nz/tonyg/projects/3-move.html.
This is free software, and you are welcome to redistribute it
under certain conditions; see http://github.com/tonyg/3-move for
details.


login: 

The database only contains one user, Wizard, to begin with. It has no password:

login: Wizard
Password: 

Logging in as player Wizard...

Welcome to MOVE.

Generic Room
~~~~~~~~~~~~
This is a nondescript room.
Wizard is here.

The @verbs command can be used to find out what commands can be sent to objects:

@verbs me
  Verbs defined on Wizard (#7) and it's parents:
    (Wizard (#7))
    @shutdown
    @checkpoint
    (Generic Player (#2))
    look
    @setpass <pass>
     ...

@verbs here
  Verbs defined on Generic Room (#3) and it's parents:
    (Generic Room (#3))
    say <sent>
    emote<sent>
    @@shout <sent>
      ...

@examine is another useful verb for finding out internal details of an object:

@examine me
  Wizard (#7) (owned by Wizard (#7))
  Location: #<object Generic Room (#3)>
  Contents: [Registry (#0), Generic Program (#6), Generic Note (#5), Generic Exit (#4),
  Generic Thing (#1)]
  Parent(s): Generic Player (#2)
  Methods: [@checkpoint-verb, @shutdown-verb]
  Slots: [verbs, connection, is-programmer, registry-number, name, awake]
  Verbs: [@shutdown-verb, @checkpoint-verb]

It's important to set a password when first logging in:

@setpass ********
  Password changed.

Users

A multi user environment without other users isn't much fun. Guest users can be added with:

@build Guest as guest1
  You created an object.
  You named it "guest1".
  It was registered as guest1 (#9).

These are special users in that any login name of guest will pick from the current guest users that are not logged in. This allows people to explore the system without creating a user. Specific users can also be created:

@build Player as chris
  You created an object.
  You named it "chris".
  It was registered as chris (#10).

Here's an example interaction of the chris user logging in:

@setpass foo
  Password changed.
@describe chris
  Editing description of #<object chris (#10)>.
  Type .s to save, or .q to lose changes. .? is for help.
2> .l
  --- Current text:
  1> You see a player who needs to @describe %r.
2> .d 1
1> An amorphous blob shimmers in the light.
2> .s
  Setting description...
  Description set.

look at me

  chris
  ~~~~~
  An amorphous blob shimmers in the light.
  (chris is awake.)

Creating Rooms

Wizards can create rooms and routes to them with @dig:

@dig here to Large Room as north
  You dig the backlink exit, named "out", from "Large Room" to "Generic Room (#3)".
  You dig the outward exit, named "north", from "Generic Room (#3)" to "Large Room".

look
  Generic Room
  ~~~~~~~~~~~~
  This is a nondescript room.
  chris, guest1 and Wizard are here.
  Obvious exits: north to Large Room

north
  Large Room
  ~~~~~~~~~~
  This is a nondescript room.
  Wizard is here.
  Obvious exits: out to Generic Room

Normal users can create rooms but can't dig paths to the new room inside an existing room they didn't create themselves. They can use go to to go to the room created and build up rooms from there. A friendly Wizard can link the rooms later if desired. The room logic is in room.move.

Programs

Programs can be written and executed within the environment. This is done by creating a Program object, editing it and compiling it:

@build Program as hello
  You created an object.
  You named it "hello".
  It was registered as hello (#11).

edit hello
  Type .s to save, or .q to lose changes. .? is for help.
1> realuid():tell("Hello World\n");
2> .s
  Edit successful.

@compile hello
  Hello World
  Result: undefined

This "hello world" example gets the current user with realuid and calls the tell method which sends output to that users connection.

The code for the Program object is in program.move. Note that the @compile verb wraps the code from the program inside a "function (TARGET) { ...code here... }". TARGET can be set using the @target verb on a program. This enables writing programs that can add verbs to objects. The tricks subdirectory has some example of this, for example ps.verbs.move that adds the @ps verb to the target:

define method (TARGET) @ps-verb(b) {
  define player = realuid();
  if (player != TARGET) {
    player:tell("You don't have permission to @ps, I'm sorry.\n");
  } else {
    define tab = get-thread-table();

    player:mtell(["Process table:\n"] + map(function(p) {
      " #" + get-print-string(p[0]) + "\t" +
    p[1].name + "\t\t" +
    get-print-string(p[2]) + "\t" +
    get-print-string(p[3]) + "\n";
    }, tab));
  }
}
TARGET:add-verb(#this, #@ps-verb, ["@ps"]);  

If that text is copied and pasted into a program, then @ps can be added to an object with:

@build Program as psprog
  You created an object.
  You named it "psprog".
  It was registered as psprog (#13).

edit psprog
  Type .s to save, or .q to lose changes. .? is for help.
1> ...paste program code above...
2> .s

@target psprog at me
  You target psprog (#13) at Wizard (#7).

@compile psprog
  Result: true

@verbs me
  Verbs defined on Wizard (#7) and it's parents:
    (Wizard (#7))
    @shutdown
    @checkpoint
    @ps
    ...

@ps
  Process table:
   #1   Wizard      false   2
   #2   Wizard      false   0
   #3   chris       false   1

Checkpointing

All changes to the system are done in memory. A checkpoint method should be called occasionally to save the current state of the database. An example of how to do this is in checkpoint.move but it can also be done by any Wizard calling @checkpoint.

Checkpoints don't overwrite the existing database - they save to a new file of the form move.checkpoint.000, where 000 is an incrementing number. When restarting a system it's important to use the last checkpoint to start from.

Programming Language

The programming language used by 3-Move is undocumented but it's pretty easy to follow from the examples. The primitives can be seen in the PRIM.*.c files in the move directory. Functions are of the form:

define function this-is-a-function(arg1, argn) {
   ...
}

The system uses a prototype object system. Objects are created by calling clone on an existing object:

// Create an object cloned from the Root object
define c = Root:clone();

Objects can have fields. These are defined as:

// Define a blah field of the new object and give it a value
define (c) blah = "foo";

// Access the blah field
c.blah;

Objects can have methods:

// Define a constructor for 'c' which gets called when cloned
define method (c) initialize() {
  as(Root):initialize();
  this.blah = "new blah";
}

Fields are accessed using the dot operator (.) and methods with the colon operator (:). There are separate namespace for fields and methods.

Objects and fields can have flags set to control permissions. An example from the source:

// Only the owner of an object can see the connection field
define (Player) connection = null;
set-slot-flags(Player, #connection, O_OWNER_MASK);

The flags are:

define O_OWNER_MASK = 0x00000F00;
define O_GROUP_MASK = 0x000000F0;
define O_WORLD_MASK = 0x0000000F;
define O_ALL_R  = 0x00000111;
define O_ALL_W  = 0x00000222;
define O_ALL_X  = 0x00000444;

define O_OWNER_R    = 0x00000100;
define O_OWNER_W    = 0x00000200;
define O_OWNER_X    = 0x00000400;
define O_GROUP_R    = 0x00000010;
define O_GROUP_W    = 0x00000020;
define O_GROUP_X    = 0x00000040;
define O_WORLD_R    = 0x00000001;
define O_WORLD_W    = 0x00000002;
define O_WORLD_X    = 0x00000004;

From within a method it's possible to query the user that called it and from there dynamically check permissions:

define method (Thing) add-alias(n) {
  if (caller-effuid() != owner(this) && !privileged?(caller-effuid()))
    return false;

  this.aliases = this.aliases + [n];
  return true;
}

This ensures that add-alias can only be called on the Thing object if the caller is the owner of the object and if they are a privileged user. Another example is:

define method (Thing) add-verb(selfvar, methname, pattern) {
  define c = caller-effuid();
  define fl = object-flags(this);

  if ((fl & O_WORLD_W == O_WORLD_W) ||
      ((fl & O_GROUP_W == O_GROUP_W) && in-group-of(c, this)) ||
      ((fl & O_OWNER_W == O_OWNER_W) && c == owner(this)) ||
      privileged?(c)) {
    ...
  }
}

Here add-verb can only be called if the object is world writeable, or group writeable and the caller is a member of the group, or owner writeable and the caller is the owner, or the caller is privileged.

Objects can also have flags set:

define method (Root) clone() {
  define n = the-clone(this);
  if (n) {
    set-object-flags(n, O_NORMAL_FLAGS);
    n:initialize();
  }
  n;
}
set-setuid(Root:clone, false);

Anonymous functions and higher order functions are available. Unfortunately there's no REPL but snippets can be tested in Program objects when logged in, or added to a move file and executed against the database. The result will be printed as part of the output:

define function reduce(f, st, vec) {
  define i = 0;

  while (i < length(vec)) {
    st = f(st, vec[i]);
    i = i + 1;
  }

  st;
}

reduce(function(acc, al) acc + al, 0, [1, 2, 3, 4, 5]);

$ ./move x reduce.move 
importing test2.move
--> true
--> 15
-->! the compiler returned NULL.

Lightweight threads are spawned using fork and fork/quota. The first version, fork takes a function to spawn in the background. It uses a default CPU quota of 15,000 cycles before it terminates:

fork(function () {
    while (true) {
      ...do something...
      // sleep for one second
      sleep(1);
    }
  });

Threads are saved in the database when checkpointed and resumed when the database is started. fork/quota allows setting a quota value other than the default of 15,000 cycles. It also allows three special values. A quota value of 0 means the thread should exit as soon as possible. -1 means the thread should run forever, with no quota, and can be checkpointed and resumed on restart like normal threads. A value of -2 means the thread runs forever but is not checkpointed and therefore not resumed at startup.

#define VM_STATE_DYING          0
#define VM_STATE_DAEMON         -1
#define VM_STATE_NOQUOTA        -2

fork/quota(function () {
    while (true) {
      ...do something...
      // sleep for one second
      sleep(1);
    }
  }, VM_STATE_DAEMON);

The language has support for first class continuations via the call/cc primitive. This works the same as the scheme call-with-current-continuation function. An example from the wikipedia page:

define function foo(ret) {
  ret(2);
  3;
}

foo(function (x) x); // Returns 3
call/cc(foo);        // Returns 2

Tricks

There is a tricks directory that contains utility code and examples. This includes an http server written in move, code for sending mail via smtp, and some bot examples.

Conclusion

The move language looks quite nice. I suspect it'd be useful for things other than virtual worlds - server side applications that can be extended with scripts safely are a common use case. I've put an example server on bluishcoder.co.nz port 7777 to experiment with. There are a few guest accounts configured:

$ nc bluishcoder.co.nz 7777

There's a port for SSL connections on 7778 that can be connected via:

$ openssl s_client -connect bluishcoder.co.nz:7778

The SSL connection was set up on the server using socat to forward to the 7777 port:

$ openssl genrsa -out move.key 2048
$ openssl req -new -key move.key -x509 -days 3653 -out move.crt
$ socat openssl-listen:7778,reuseaddr,pf=ip4,fork,cert=./move.pem,verify=0 TCP:127.0.0.1:7777

FedEx (yes, the shipping company) put up an interactive piece that audiolizes a package’s journey, based on its origination and where it passes through. Either put in your own tracking number or just enter your own locations. I’m not sure I get a ton out of the sound variation, because I don’t know what I’m listening to exactly, but I like the aesthetic. Plus it’s fun.

Tags: audiolization, FedEx

The last time we made significant changes to our governance was 4 to 5 years ago [1, 2, 3]. It's time to evolve it more. We need to:

• Update the governance model so governance policies and community membership decisions are not determined by me or by me alone. It is clear that the current governance structure of Drupal, which relies on me being the ultimate decision maker and spokesperson for difficult governance and community membership decisions, has reached its limits. It doesn't work for many in our community -- and frankly, it does not work for me either. I want to help drive the technical strategy and vision of Drupal, not be the arbiter of governance or interpersonal issues.
• Review our the Code of Conduct. Many have commented that the intentions and scope of the Code of Conduct are unclear. For example, some people have asked if violations of the Code of Conduct are the only reasons for which someone might be removed from our community, whether Community Working Group decisions can be made based on actions outside of the Drupal community, or whether we need a Code of Conduct at all. These are all important questions that need clear answers.

I believe that to achieve the best outcome, we will:

1. Organize both in-person and virtual roundtables during and after DrupalCon Baltimore to focus on gathering direct feedback from the community on evolving our governance.
2. Refocus the 2-day meeting of the Drupal Association's Board of Directors at DrupalCon Baltimore to discuss these topics.
3. Collect ideas in the issue queue of the Drupal Governance project. We will share a report from the roundtable discussions (point 1) and the Drupal Association Board Meeting (point 2) in the issue queue so everything is available in one place.
4. Actively solicit help from experts on diversity, inclusion, experiences of marginalized groups, and codes of conduct and governance. This could include people from both inside and outside the Drupal community (e.g. a leader from another community who is highly respected). I've started looking into this option with the help of the Drupal Association and members of the Community Working Group. We are open to suggestions.

In order to achieve these aims, we plan to organize an in-person Drupal Community Governance sprint the weeks following DrupalCon Baltimore, involving members of the Drupal Association, Community Working Group, the Drupal Diversity & Inclusion group, outside experts, as well as some community members who have been critical of our governance. At the sprint, we will discuss feedback gathered by the roundtables, as well as discussions during the 2-day board meeting at DrupalCon Baltimore, and turn these into concrete proposals: possible modifications to the Code of Conduct, structural changes, expectations of leadership, etc. These proposals will be open for public comment for several weeks or months, to be finalized by DrupalCon Vienna.

We're still discussing these plans but I wanted to give you some insight in our progress and thinking; once the plans are finalized we'll share them on Drupal.org. Let us know your thoughts on this framework. I'm looking forward to working on solutions with others in the community.

Last year, we partnered with Trinket to develop a web-based emulator for the Sense HAT, the multipurpose add-on board for the Raspberry Pi. Today, we are proud to announce an exciting new upgrade to the emulator. We hope this will make it even easier for you to design amazing experiments with the Sense HAT!

What’s new?

The original release of the emulator didn’t fully support all of the Sense HAT features. Specifically, the movement sensors were not emulated. Thanks to funding from the UK Space Agency, we are delighted to announce that a new round of development has just been completed. From today, the movement sensors are fully supported. The emulator also comes with a shiny new 3D interface, Astro Pi skin mode, and Pygame event handling. Click the ▶︎ button below to see what’s new!

Upgraded sensors

On a physical Sense HAT, real sensors react to changes in environmental conditions like fluctuations in temperature or humidity. The emulator has sliders which are designed to simulate this. However, emulating the movement sensor is a bit more complicated. The upgrade introduces a 3D slider, which is essentially a model of the Sense HAT that you can move with your mouse. Moving the model affects the readings provided by the accelerometer, gyroscope, and magnetometer sensors.

Code written in this emulator is directly portable to a physical Raspberry Pi and Sense HAT without modification. This means you can now develop and test programs using the movement sensors from any internet-connected computer, anywhere in the world.

Astro Pi mode

Astro Pi is our series of competitions offering students the chance to have their code run in space! The code is run on two space-hardened Raspberry Pi units, with attached Sense HATs, on the International Space Station.

There are a number of practical things that can catch you out when you are porting your Sense HAT code to an Astro Pi unit, though, such as the orientation of the screen and joystick. Just as having a 3D-printed Astro Pi case enables you to discover and overcome these, so does the Astro Pi skin mode in this emulator. In the bottom right-hand panel, there is an Astro Pi button which enables the mode: click it again to go back to the Sense HAT.

The joystick and push buttons are operated by pressing your keyboard keys: use the cursor keys and Enter for the joystick, and U, D, L, R, A, and B for the buttons.

Sense Hat resources for Code Clubs

We also have a new range of Code Club resources which are based on the emulator. Of these, three use the environmental sensors and two use the movement sensors. The resources are an ideal way for any Code Club to get into physical computing.

The technology

The 3D models in the emulator are represented entirely with HTML and CSS. “This project pushed the Trinket team, and the 3D web, to its limit,” says Elliott Hauser, CEO of Trinket. “Our first step was to test whether pure 3D HTML/CSS was feasible, using Julian Garnier’s Tridiv.”

“We added JavaScript rotation logic and the proof of concept worked!” Elliot continues. “Countless iterations, SVG textures, and pixel-pushing tweaks later, the finished emulator is far more than the sum of its parts.”

Check out this blog post from Trinket for more on the technology and mathematics behind the models.

One of the compromises we’ve had to make is browser support. Unfortunately, browsers like Firefox and Microsoft Edge don’t fully support this technology yet. Instead, we recommend that you use Chrome, Safari, or Opera to access the emulator.

Where do I start?

If you’re new to the Sense HAT, you can simply copy and paste many of the code examples from our educational resources, like this one. Alternatively, you can check out our Sense HAT Essentials e-book. For a complete list of all the functions you can use, have a look at the Sense HAT API reference here.

The post Sense HAT Emulator Upgrade appeared first on Raspberry Pi.

The invisible hand never picks up the check.

― Kim Stanley Robinson, New York 2140

During the late 19th and early 20th centuries, women began to escape some of their restrictions by riding bicycles. Despite strong opposition from men, women cycled on, and the bicycle became an instrument of change that subverted the status quo and became a powerful symbol of women's emancipation. In this post, Andrew McLaughlin tells us all about the extraordinary role played by bicycles in women's emancipation.

The post How the Bicycle Became a Symbol for Women’s Emancipation appeared first on Average Joe Cyclist.

I keep hearing myself in meetings talking about the “need” to get people coding, but that’s not really what I mean, and it immediately puts people off because I’m not sure they know what programming/coding is or what it’s useful for.

So here’s an example of the sort of thing I regularly do, pretty much naturally – automating simple tasks, a line or two at a time.

The problem was generating some data files containing weather data for several airports. I’d already got a pattern for the URL for the data file, now I just needed to find some airport codes (for airports in the capital cities of the BRICS countries) and grab the data into a separate file for each [code]:

In other words – figuring out what steps I need to do to solve a problem, then writing a line of code to do each step – often separately – looking at the output to check it’s what I expect, then using it as the input to the next step. (As you get more confident, you can start to bundle several lines together.)

The print statements are a bit overkill – I added them as commentary…

On its own, each line of code is quite simple. There are lots of high level packages out there to make powerful things happen with a single command. And there are lots of high level data representations that make it easier to work with particular things. pandas dataframes, for example, allow you to work natually the contents of a CSV data file or an Excel spreadsheet. And if you need to work with maps, there are packages to help with those too. (So for example, as an afterthought I added a quick example to the notebook showing how to add markers for the airports to a map… (I’m not sure if the map will render in the embed or the gist?) That code represents a recipe that can be copied and pasted and used with other datasets more or less directly.

So when folk talk about programming and coding, I’m not sure what they mean by it. The way we teach it in computing departments sucks, because it doesn’t represent the sort of use case above: using a line of code at a time, each one a possible timesaver, to do something useful. Each line of code is a self-made tool to do a particular task.

Enterprise software development has different constraints to the above, of course, and more formalised methods for developing and deploying code. But the number of people who could make use of code – doing the sorts of things demonstrated as per the example above – is far larger than than the number of developers we’ll ever need. (If more folk could build their own single line tools, or work through tasks a line of a code at a time, we may not need so many developers?)

So when it comes to talk of developing “digital skills” at scale, I think of the above example as being at the level we should be aspiring to. Scripting, rather then developer coding/programming (h/t @RossMackenzie for being the first to comment back with that mention). Because it’s in the reach of many people, and it allows them to start putting together their own single line code apps from the start, as well as developing more complex recipes, a line of code at a time.

And one of the reasons folk can become productive is because there are lots of helpful packages and examples of cribbable code out there. (Often, just one or two lines of code will fix the problem you can’t solve for yourself.)

Real programmers don’t write a million lines of code at a time – they often write a functional block – which may be just a line or a placeholder function – one block at a time. And whilst these single lines of code or simple blocks may combine to create a recipe that requires lots of steps, these are often organised in higher level functional blocks – which are themselves single steps at a higher level of abstraction. (How does the joke go? Recipe for world domination: step 1 – invade Poland etc.)

The problem solving process then becomes one of both top-down and bottom up: what do I want to do, what are the high-level steps that would help me achieve that, within each of those: can I code it as a single line, or do I need to break the problem into smaller steps?

Knowing some of the libraries that exist out there can help in this problem solving / decomposing the problem process. For example, to get Excel data into a data structure, I don’t need to know how to open a file, read in a million lines of XML, parse the XML, figure out how to represent that as a data structure, etc. I use the pandas.read_excel() function and pass it a filename.

If we want to start developing digital skills at scale, we need to get the initiatives out of the computing departments and into the technology departments, and science departments, and engineering departments, and humanities departments, and social science departments…

 

When this picture was taken in 1932 it was noted as being a picture of the last locomotive to cross West Hastings Street. It was on the route that angled through the Downtown from Alexander to the freight yards by False Creek. From July 1932 a newly bored tunnel allowed trains to move between Burrard Inlet and False Creek. The tunnel – or much of it – still exists because SkyTrain now runs through it to head to Waterfront from Stadium station. The tunnel was dug a little deeper to allow the SkyTrain tracks to be stacked on top of each other – the tunnel wasn’t wide enough to allow two trains to run side by side.

We’re not trainspotters, so we could be quite wrong, but this looks as if it was Canadian Pacific’s locomotive 232; an old 0-6-0 steam engine that would have probably been used to haul carriages and freight cars over short distances within the city between CP’s various freight yards. In an earlier post we featured one of the bigger locomotives used to haul the passenger trains across country, sitting on the same line, on Alexander Street.

The building on the left of the picture was the Headquarters of the BC Electric Railway Co who ran the tram and interurban system, which by the 1930s was apparently also doing double duty for Westminster Motor Coach. The odd thing is that this appears to be the only reference to an organization of that name. We haven’t found any records for an operation with that name, and it doesn’t appear in any street directories either. W Marwell Somervell designed the building, completed in 1911, and still in use today as a lighting showroom with offices above. (The building permit for the $350,000 project identified him as M Somervell).

One other thing we noted is the sign on the building for “BC Rapid Transit Coaches” We had no idea the term was in use so early – although with a slightly different meaning. In 1930 there was a scheduled coach to Seattle (which went through Sumas) and another to Chilliwack. Fares from Chilliwack to Seattle were $3.50, return $6.00, but to Bellingham only cost $1 ($1.50 return).

Image source: City of Vancouver Archives Can N32

Photo: Waterfield Designs

I am a sucker for great bags and while I read Waterfield backpacks are an expensively acquired taste I came across this picture and it hit me that we are now making bags that can hold a MacBook and an iPad. A MacBook is a great laptop and an iPad is the best tablet, but what if you need both? You carry two machines, plus your phone. Ever since I had the Surface 3, I left the MacBook at home and carried the iPad (Pro) or Surface 3 on travels.

This has changed with Surface Pro 4. Ever since I had this machine, I shut down my Macs when I am not using them. That had never happened before. I just put them to sleep because I would need them the next minute. Not any more.

These two-in-one machines have a lot going for them. I have my working set of documents in the cloud, replicated to several computers, the rest is in background storage. With Surface Pro 4 it's all there. I can go from notebook to tablet in a second, I love how well inking is integrated into Windows 10. I love how the pen is more useful than Pencil on iPad Pro. There aren't many "apps" for Windows on Surface, but frankly, I don't need a Youtube app. I just use Edge for everything. And with Creators Update, even for reading books. Some of the apps are really good, like Instagram which displays photos at high resolution, or Netflix which lets you download shows to watch them later.

While I found many devices that end the quest for the best one -- Sonos for music at home, Dyson for vacuums, iPhone for smartphones, Apple Watch for fitness trackers, AirPods for wireless earbuds -- the journey for the perfect computer isn't over. But at this point in time, Surface Pro 4 is the best answer for me.Why is that? I love beautiful objects. Windows 10 is beautiful, the machine itself is beautiful, the fuzzy keyboard and the pen are as well. I love functional objects, and Surface Pro 4 has it all: pen, touch, keyboard, trackpack, screen, all of them outstanding. And the thing that Microsoft really nailed is the kickstand. I use it all the time, even while Surface is in tablet mode.

I currently have three (active) Macs and quite a few (read: more) Windows machines. Surface Pro 4 is the one I use.

We read about time-saving tricks so we have more time to read about time-saving tricks. We optimize our morning routines so we can have 30 minutes longer each morning to work more. It seems like we collectively want more time simply because we want to cram more into the time we’ve got.

The post What’s the point of productivity? appeared first on Paul Jarvis.

Mapping geographic data in R can be tricky, because there are so many ways to complete separate tasks. It’s a jumble of options and you have to figure out how to put the pieces together. This course walks you through the steps so that the process isn’t so jumbley.

FlowingData members can access the course right now. Learn how to load geographic data, draw boundaries, map locations, and make data-driven maps that are publication-ready. Then refine the process and learn how you can apply it to your own data.

Not a member yet? Join now, and gain instant access to this course and others, along with the full visualization tutorials collection.

Membership details.

Tags: course, R

My last post I did mention that I was in the semi-last stages of editing the new book. I’m about a third of the way through it, and hope to finish this phase this week. On top of that, I have a few minor developmental changes to make based on some feedback from some people who were nice enough to read it in its unfinished state. They haven’t died or stopped talking to me, so that’s a good sign. Releasing soon!

I’ve been thinking about the editing process itself. After you’ve written your 95,000 word novel, and gone back through it and rewritten chunks and fiddled around with the words, you pass it off to an editor. In this case, I sent it to Scarlett Algee, introduced to me by Nathan Hystad whom I worked with on the last Explorations anthology. It was fun, and Scarlett was pretty swell to work with. [I’m not sure she’s keen on being associated with this project yet, but I should ask her about that before I push publish. Oops.] She took my manuscript, read it, marked it up and returned it to me in just under a couple of weeks. She is like some kind of word and punctuation machine and I’m really impressed with the quality and speed of her work.

While this all feels like an eternity to me, having committed to releasing back in January, then giving February a miss, now onto mid-April, it’s made me realize that the much-maligned Traditional Publishing industry has one thing right: These things take time. Typically, a traditionally-published novel spends a full year in development with a variety of editors, proof-readers and loops back to the author. I’m giving it a couple of months. And I’m doing a lot of it myself. Formatting, proofing, layout, … Some of that shit is really fiddly – and a pain in the ass, to be quite honest. It is the main reason I haven’t released a print copy of Trajectory Book 2 yet: I can’t bring myself to put it together in InDesign.

But I will. Over the next couple of months, while the new book is percolating on the shelves, I intend to get a bundled edition of Book 1 and 2 together with a print version. I think it’s worth it. People have complained about the truncated ending in Book 1 and I think that’s valid. “It feels like this was just cut off from a larger book” is an exactly correct criticism. You caught me! Release early, release often, we used to say in the software industry.

While all that’s happening, I just put the pen cap on after an 11,000 word short story and have begun plotting and outlining for Book 4. It’s easy to make a lot of work for yourself without really trying.

That’s enough procrastination. Back to work.

PS, if you have read either of the Trajectory Books, or any other indie author’s work, and haven’t left a review, please take a second to drop some stars on them. Stars and reviews help us stay visible. Thank you!

The role of a data scientist is one of the hottest jobs in the industry today – But how do we inspire the next generation of data scientists?

I have been working on the idea of Young Data Scientist for a years now – with various iterations and pivots

Its now ready to launch the next version as a book / kickstarter

The easiest way to inspire the next generation of Data Scientists is to go back to the basics – i.e. the Maths because Maths is the Universal language that underpins progress and innovation

This also aligns closely with my day job and my teaching – Data Science for Internet of Things at Oxford University

It allows me also to create the book /kickstarter using personal insights from my years of teaching

So, if you consider the maths foundations needed to learn Data Science, you could divide them into four key areas

Linear Algebra

Probability Theory and Statistics

Multidimensional Calculus

Optimization

All of these are taught(in some shape or form) in high schools(13 to 17 years)

So, the book aims to build upon these foundations for a high school audience to inspire them to take up Data Science

The challenge here is to simplify and co-relate to existing maths knowledge considering the audience(13 to 17 year olds)

and most importantly to inspire!

It also would take them on a path to be Artificial Intelligence(AI) aware

Young Data Scientist will be a book, a kickstarter, a community

It will have Open source foundations

Young Data Scientist community will also work with teachers

And finally, the Young Data Scientist community will draw upon interesting examples in Space exploration, Genomics, Ecology etc

Coding will be in Python (including numpy and tensorflow sometimes)

Please email me at ajit.jaokar at futuretext.com

All wars are fought twice, the first time on the battlefield, the second time in memory.

— Viet Thanh Nguyen

James Gallagher, BBC News, Apr 13, 2017

---

If (and it's a big if) this thesis (pay-walled study) is correct, then proponents of  cognitive load theory have a lot of rethinking to do. The suggestion is that while brains do indeed store short-term and long-term memory, they store these using two separate processes. So a memory doesn't have to be squeezed through short-term memory before it becomes a long-term memory. This makes a lot of sense to me - people like Romeo Dallaire  talk about detailed complex traumatic memories of wartime where the entire experience stored and plays back over and over, brushing by the limits of cognitive overload as if they didn't even exist. "Post-traumatic stress disorder hard-wires events in your brain to the extent they will come back in digitally clear detail to your brain. You don't actually remember them. You relive them."

[Link] [Comment]

Or, how to choose an IoT cloud platform for your new Internet thing.

A critical step building any new product (IoT or otherwise) is to quickly make your innovation tangible, then iterate and refine. This is often referred to as building a Minimum Viable Product; but, I think that’s belittling. This step of the process is crucial because it changes what only existed in your mind or on paper into a vibrant, living process. It requires focus and flow, which can be hard to maintain.

It follows that when choosing your prototyping platform, you don’t want anything that breaks your focus and flow: endless dependencies; laborious build processes; sudden, steep learning curves; having to build non-innovative pieces from scratch; and, too many distracting options.

Some things you do want: a minimal setup cost; useful, pre-existing building blocks; helpful constraints; and, tools you can depend on.

The IoT Cloud Platform Landscape

Truly innovative ideas are beyond the paradigm of component-or-widget-based, drag-and-drop IoT builders. You’ll need — and want — to write your own firmware, and that puts you square in the land of embedded systems programming and/or Arduino.

Even after ruling out those that are too simplistic, there are countless IoT platforms to choose from. Focussing in on those that support both observation and control, excluding those that focus solely on data collection, reduces the available platforms to a manageable number.

A cluster of major players (eg. AWS IoT, Azure IoT Hub, and Google Weave) are relatively hardware-agnostic and present a similar idea of what a “thing” should be.

Chip Choices

By hardware-agnostic, I mean they provide an SDK that works with a variety of processors. For whichever chipset you choose, you’ll also need to learn a build chain and set up your development environment, which includes building with the platform’s SDK, before you get started.

And that leads to questions about how you program, flash, update, and connect your devices. While there are some great choices, this particular rabbit hole runs deep, and a lot of time can slip by before you even get started.

Talking to Your Thing

At the heart of these platforms’ understanding of things are properties like “on” or “off” or “68°” or “up,” and interactions with your thing change those properties or react to changes in them.

If you want turn a light switch thing on, you request the power property be set to “on.” To set a thermostat, you request the targetTemperature property be set to “68°.” The associated cloud platform will (hopefully) keep track of the status of your request and whether the thing’s properties matches what’s reported on the device, so you can find out if your request was successful. In AWS, this is referred to as a “Thing Shadow,” while Azure has a “Device twin.” Hey, nobody said these things were all settled and tidy, these are early days.

Some platforms understand the idea of sending a thing a command, while other only allow you to send generic messages to the device.

This is a pretty good—perhaps great—way to approach prototyping your thing. But this open-ended, property driven approach can get you bogged down in data modeling and premature refactoring, when you should be coding and building. Another deep rabbit hole, and no sign of focus or flow.

A Middle Way

Fortunately, there is a platform avoids both of these rabbit holes: Particle.

With one of their processors, your thing can be connected to a fully-featured IoT Cloud within minutes over wifi (Photon) or cellular (Electron). You can start programming it right away using their online IDE, or after a simple download with their Atom-based desktop IDE. No multi-part toolchains, build configurations, temperamental cloud authentication processes. Focus!

Even better, both of these IDEs support compiling online and updating your firmware over the air (OTA), so your device can remain operating in situ while you iterate and debug. Flow!

Second, the Cloud API is quick and easy to understand. You can define up to 20 variables (properties) which can be altered by the device, and 15 cloud functions (commands) that can alter those variables or perform other tasks.

Particle’s simplified cloud model clears a path to building the essential functions and activities of your internet thing. Particle still provides access to the more complex features of a message-driven model with what they call Events; but, you can get quite far with just variables and functions.

As a bonus, the Particle chips are Arduino-compatible processors, so you have access to plenty of already-ported libraries that interact with sensors, LEDs, servos, network requests, and much more. Even if a library hasn’t been ported, it’s likely relatively simple to do so yourself, alongside plenty of tutorials and guides to get you going programming with Arduino.

Bonus 2: There’s a mature and extensive community on Hackster, with 628 projects and counting you can use as templates for your own, or just as a self-study program.

Finally, Particle is opening up connectivity to their cloud to other hardware platforms. So, if you need BLE, you can flash your code to a RedBear Duo or bluz. Or, if you need the backing of a complete computer, you can flash to a Raspberry Pi.

As You Grow

With an easy start, plenty of building blocks and examples, and useful constraints, Particle hits a sweet spot for capturing and iterating your innovation.

As you continue development, you’ll want to explore other platform and IoT development models. You may find that the way the structure their cloud interactions and data better achieves your goals. But, in my mind, there really is currently no better place to get started than with Particle.

I learned everything here by going through it myself. I also found things that I thought could be easier for others, so I built something to do just that.

If you’re starting out on the Particle Cloud I invite you to check out Porter. It’s a customizable, cloud-based interface for any Particle device, saving you the need to code a UI, message storage, notifications, device sharing, and more.

You can get an overview with the screencasts on the Porter YouTube channel, or check out some projects on the Porter Hackster community. Whatever you’re working on, good luck!

---

On Avoiding Rabbit Holes was originally published in Bright/Contrast on Medium, where people are continuing the conversation by highlighting and responding to this story.

This was a nice surprise - in fact, it was the best news all day.

Lindsay McKenzie, Chronicle of Higher Education, Apr 13, 2017

---

I've started using Unpaywall, a browser extension that finds open access versions of closed access publications. For example, is a search takes me to a closed Elsevier article, Unpaywall might find the Arxiv version. Too Cool. "We’ re setting up a lemonade stand right next to the publishers’ lemonade stand," says Mr. Priem. "They’ re charging $30 for a glass of lemonade, and we’ re showing up right next to them and saying, ‘ Lemonade for free’ ." I'm just waiting for them to find a way to declare this illegal. Also, free lemonade. They'll declare that illegal too.

[Link] [Comment]

Our Kitchen... what I wish I could change about our space.

Pictured: Hay About a Chair from Inform Interiors, Table a Craigslist Find, Rug from Urban Outfitters, 

Normally I am of the mindset that if you don't like something about your space, you should change it. Giving up our bedroom and putting a murphy bed in our living room, was an easy transition that we have never regretted. Fitting two kids into a small bedroom has been relatively smooth. As we have made changes and improvements to make our space work for our lifestyle there is one thing that bothers me that I can't find my way around.

One of the main reasons we can do so much in 600 square feet is because of our open floor plan. But the fact that our kitchen is in the middle of our space is the one thing that really bothers me and I can't find a way to resolve it. Our kitchen is a full size kitchen along the north wall of our apartment.  It is white with clean lines and fixtures that still look modern 12 years after it was built. Beside the appliances being a bit old, there is nothing wrong with it, but I wish that I didn't always have to see it!  If I could redesign our space the kitchen would be more of a galley style kitchen or at minimum have a partial wall covering it.  It is easy to cook and clean in the open kitchen and keep an eye on the kids but a messy kitchen makes the whole space feel messy. Our open concept kitchen is the one problem in our space that I can't solve with furniture or paint or styling. My best solution at the moment is to keep the kitchen as clean as possible and free from countertop clutter (not an easy task!) but it still doesn't solve the issue. 

No space is perfect and I am grateful for what we have and what we have done with it.  But a slightly hidden kitchen is at the top of my list if we ever move. What's the one thing you wish you could change about your space? 

The post Let DJ Khaled give you major keys [Bot of the Week] appeared first on MobileSyrup.

Google is reportedly offering to invest up to $880 million (1 trillion won) to help LG Display in boosting its production of OLED panels for smartphones. The company is making the offer in a bid to secure supplies of flexible OLED panels for future Pixel smartphones. Continue reading →

Every week we bring you the latest in Canadian mobile news. Listed below is a quick overview of the top stories from the past seven days.

• iPad (2017) review: Perfect for first-time tablet buyers [Read here]
• Apple’s new app Clips is the perfect mobile video editing companion [Read here]
• Canadian national public alerting system to soon notify smartphones of emergencies [Read here]
• Here are the best and most affordable microSD cards for the Nintendo Switch [Read here]
• Canadian Privacy Commissioner voices concerns with connected and automated vehicles [Read here]
• Here’s everything hitting CraveTV in April [Read here]
• Sonos Playbase Review: The opposite of ‘flat’ audio [Read here]
• Freedom Mobile overhauls rate plans, launches new LTE data offerings [Read here]
• Telus donates thinkFull mental wellness app to CMHA [Read here]
• Google Pixel XL put on discontinued list at Rogers and Fido [Read here]
• Wi-Fi calling coming to some Freedom Mobile customers ‘within weeks’ [Read here]
• CCTS reveals top wireless complaint by Canadians is carriers misleading information about terms [Read here]
• Canadian music streaming subscriptions doubled in 2016: report [Read here]
• LG G6 can now be purchased for $839 no-term in Canada [Read here]
• Freedom Mobile expands its LTE network, adds new LTE roaming partner [Read here]
• Canadian carriers should offer unlimited data: Toronto City Council to CRTC [Read here]
• Apple launches new ‘Made in Toronto-Waterloo’ App Store section as part of Canada 150 [Read here]
• Bell to drop promo data pricing in Quebec, 10GB data add-on will be $40 [Read here]

The post Top Canadian mobile stories from the past week appeared first on MobileSyrup.

For an OS meant for smartphones and smart devices, Android can surprisingly fail at some very basic tasks. This includes the ability to set a custom ringtone or notification sound which is unnecessarily complex in stock Android. Continue reading →

Andrew McGill, The Atlantic, Apr 12, 2017

---

This is a pretty good example of what can be done with analytics. As we know, there are the tweets Donald Trump writes himself, and then there are tweets written by his press office. The two have different styles, as was noted last year. The twitter bot takes advantage of this. "It’ s a Twitter bot that uses machine learning and natural language processing to estimate the likelihood Trump wrote a tweet himself." This is of course a novelty but it's the same sort of logic that can be used to filter spam, and eventually, to identify individual students by their  writing style and typing cadence.

[Link] [Comment]

Sahil Patel, Digiday, Apr 12, 2017

---

The 'duopoly' in question is Facebook and Google, and arguably these two platforms have a firm hold on platform traffic. This article points out that this is not a good deal for publishers. Bloomber's Media CEO Justin Smith Smith cited a recent study from Digital Content Next showing "only 14 percent of some publishers’ revenues were coming from distributed content." How, then do publishers succeed? Quartz has a good model. "Quartz’ s model from the beginning has been to never accept a banner ad or an IAB standard unit." Also, "If you’ re producing content that someone else is also producing, you have to stop right away and rethink your approach. Create content that no one else is producing."

[Link] [Comment]

Joseph Lichterman, Nieman Lab, Apr 12, 2017

---

I'm not sure whether this represents a sea change or is just a blip, but the New York Times, which was one of the original partners when Facebook launched  Instant Articles in 2015, has not ceased publishing that way. It still publishes a lot of content to platforms (as do most major publishers) but now in the form of links rather than full content. It is worth noting that the Times is trying (still) to make its way as a subscription-based service. This article documents the trend for a number of publishers.

[Link] [Comment]

Last week Megan Sanicki, executive director of the Drupal Association, and I published a joint statement. In this blog post, I wanted to follow up with a personal statement focused on the community at large.

I've talked to a lot of people the last two weeks, and it is clear to me that our decisions have caused much alarm and distress in our community. I feel this follow-up is important even though I know it doesn't undo the hurt I've caused.

I want to deeply apologize for causing grief and uncertainty, especially to those in the BDSM and kink communities who felt targeted by the turmoil. This incident was about specific actions of a single member of our community. This was never meant to be about sexual practices or kinks, so it pains me that I unintentionally hurt you. I do support you and respect you as a key part of our community.

Shortly after I started Drupal more than 15 years ago, I based its core values on openness and equality. Gender, race, religion, beliefs, sexuality ... all are welcome in our community. We've always had people with wildly different views and identities. When we walk into a sprint at DrupalCon, we've been able to put our opinions aside, open our laptops, and start collaborating. Diversity has always been a feature, not a bug. I strongly feel that this foundation is what made Drupal what it is today; a global family.

Serving a community as unique and diverse as Drupal is both rewarding and challenging. We've navigated through several defining moments and transitions in our history. I feel what we are going through now is another one of these defining moments for our culture and community. In an excruciating but illuminating way this has shown some of what is best about our community: we care. I'm reminded that what brings us together, what we all have in common, is our love and appreciation of open-source software. Drupal is a positive force, a collective lifting by thousands and thousands, created and maintained by those individuals cooperating toward a common goal, whose other interests have no need to be aligned.

I want to help our community heal and I'm open to learn and change. As one of the next steps, I will make a follow-up post on improving our governance to a healthier model that does not place such sensitive decisions on me. I love this community, and recognize that the things we hold in common are more important than our differences.

(Comments on this post are allowed but for obvious reasons will be moderated.)

mkalus shared this story from Saturday Morning Breakfast Cereal.

---

Click here to go see the bonus panel!

Hovertext:
Then, by being a loving father, you can fool her into wanting more babies. And, fellas, you know exactly what that means.

New comic!
Today's News:

We ran out of regular non-student tickets for BAHFest East, so we moved 20 over from a different category. Get'em while they exist!