Skip to main content Skip to navigation

About the CONSTRUIT! environment for making construals (November 2016)

The environment for making construals (MCE) has undergone major development since the visit to Athens for the second Transnational Project Meeting C2-M2 in September 2015. These are in line with the innovations that were outlined at the time. Nick Pope, with the support of Elizabeth Hudnott and Jonny Foss, has transformed the environment. A prototype version ("construit.c6") was deployed for the C6 meeting at Warwick in December 2015. This has since been refined to take account of feedback and our practical experience of its use. Documentation and illustrative examples are still in the process of being developed: the objective for this webpage is to collate sources that are helpful in learning about this latest version. Much futher work will be needed to refine and consolidate these resources.

We shall follow the convention that we have used throughout the project to date of naming variants of the MCE in association with the project activities at which they are deployed. In future, we aim to linked these to versions of the environment with a release number. For instance, construit.c15 corresponds more or less to the version: of June 22nd 2016, the latest version of JS-Eden is scifest16.

By comparison with previous versions of the MCE, and the variants of EDEN that were its precursors, the latest version of the MCE has had little exposition and trialling. It also has many new unprecedented features: an integrated maker interface in which editing and executing scripts/agents are brought together, a project manager, a much more dynamic and sensitive parser that can support "live editing", and radically different ways of formulating scripts through 'scoping' of definitions and of framing agency using 'when-clauses'. These innovations can be seen as enhancing the repertoire of techniques that were available in previous versions (it is still possible - and perhaps necessary - to introduce functions and procedures / triggered actions, and you can still copy-and-paste input from an external editor). To that extent, the new MCE subsumes previous variants, being to a very large extent backward compatible. Experience of working with the new environment will soon make it apparent that it offers scope for something quite different in character from what has been possible before. Broadly speaking, though the spirit in making construals has always been to conceive interaction in highly personal, indexical terms, so that each agent is regarded as acting from a different perspective, this vision has been realised in a clumsy manner. Specifically, the core model of interaction has been rooted in conventional computer constructs, such as functions, procedures and objects, that have an objective status and formal meaning. In the new environment, agent iteractions can be crafted with direct reference to the observations of the agent. This makes it possible to respect and reflect the individuality of agents to a much higher degree, and to generate construals in keeping with the spirit of constructivism, whereby what is deemed to be objective emerges from the melding together of personal perspectives.

There are several practical consequences of these radical developments in the MCE:

  • the vocabulary for describing the MCE and its application is still in flux. For instance, the terms associated with 'interpreting a script' in the MCE include run, execute and import. Some rationalisation of these terms is required: either by way of selecting a single term (for the novice), or explaining the nuances (for the expert). One of the core ideas behind James's radical empiricism is that words are not sufficiently subtle and expressive where our experience of making connections is concerned. On this basis, the descriptive terms used may be expected to remain to some degree informal and diverse, though this is not a justification for not attempting to clarify them.
  • even though we can still invoke the well-established and familiar approaches to making construals, this isn't necessarily desirable. Exploiting the new variant of the MCE is not simply a matter of doing what we have done before better, but of learning to do things in a new way. As Nick Pope observes, the introduction of his new concepts, such as 'with' and 'when', has a major impact on the making process. Before we can fully understand the implications of this, new experience is needed. It appears, for example, that it is no longer as essential to rely on concepts such as functions and procedures that have always featured prominently in building non-trivial construals in the past. On this basis, it may be appropriate to deprecate these techniques where our intention is to practice authentic construction.

There are broadly two kinds of material relating to the current MCE: reference material, tutorial-style examples, worksheets and illustrative construals with and without associated commentaries.

A number of construals and related resources by way of worksheets and presentations were first prototyped at the C6 learning activity. Most are still under development. These resources are now stored (both for private and public access) online in a (prototype!) project repository. The great virtue of this repository is that it is changing the culture of making construals radically - enabling discretionary access to all previous versions of construals for instance. The way in which these resources are most appropriately stored has also been transformed. Whilst it is still feasible to store resources as if they were monolithic objects (think of the original JSPE presentation for the MENACE construal for instance), it is far more appropriate to compile resources from several smaller components. This is in some respects a matter of restoring practices for organising scripts from simple components via a 'run' script that were used before JS-EDEN was developed. In conjunction with the innovations discussed above, the implications are much more far reaching: it becomes possible to think of populating the repository with construction kits of basic components that can simply be imported and reused. There is also rework to be done in simplifying existing construals that can help to make this transformation (for instance general resources for handling arithmetic in different bases, representing permutations or symmetry classes might be extracted from the MENACE construal). The main caveat about the project repository in its current ("prototype!") form is that it will require an effective interface to the maker that will take time to conceive and implement. Until such an interface has been developed, the repository will continue to be a maze that will become a progressively less friendly place to visit.

To try out the resources in the repository (in their and its as yet unfinished form!) you can left click on the pop up menu icon at the bottom right of the 'input' tab in the MCE and select the 'Browse Agents' option. You can then use the tick boxes to select the construal you wish to load, and click the 'Add' button. The construal will be represented by one or more tabs that appear in the input interface. To run the script in a given tab, select the tab with the right mouse button and left click the 'Run(force)' option. (Note that - in contrast to earlier versions of the MCE - the input does not disappear from the tab when it has been run.) For further guidance on how to use the new MCE, consult the JSPE presentation that you can obtain by loading the 'mce' construal. You can use the project management facility for storing your own work - as documented on the wiki for the GitHub site for JS-EDEN. For an explicit account of the logistics of loading and studying a construal in the MCE, consult Steve Russ's guidance on following the givingchange presentation.

A rough-and-ready catalogue of resources that are under development for the latest variant of he MCE, with a few supplementary notes on each, is given below.

References and resources

The wiki for the GitHub site for JS-EDEN contains some useful reference material. This includes documentation on using the project manager as cited above. Not all the links in the wiki point to actual resources (!) and not all are aptly named.

The mce construal in the project repository is a form of documentation of the environment for making construals wthin the environment itself ("a construal of the MCE"). It was developed as an introductory resource for the C6 activity, and will in due course be extended to include introductory accounts of the when and with features.

More tutorial resources developed by Nick Pope specifically to demonstrate the key concepts and potential of the MCE include:

  • tutorials/scoping
  • nick/circuit
  • mario

The following group of three thematically linked resources was deployed as a sequence of introductory activities for C6. Suitably packaged, it could potentially form part of the open online course:

  1. purse - this takes the form of a 'worksheet' that gives some basic orientation for working with construals
  2. makefromscratch - this worksheet gives an account of making a construal from scratch. It illustrates the central role that "making connections in experience" plays in making construals and how construals can be combined.
  3. c6/givingchange/versions1and2 - these resources include concise construals for the activity of 'giving change', one of which illustrates how scoping of definitions (with recursion) can be used to eliminate functions and procedures. The construction of the construal is outlined step-by-step in an associated commentary. The 'givingchange' construal is of interest both in relation to primary programming teaching (cf. Phil Bagge's Coins example of a simple Scratch program) and from a mathematics education perspective.

Older resources that have been or are still in the process of being re-engineered include:

  • jugs
  • c6/roomexercise
  • lift/jigsawexpt
  • hexcolouring
  • c6/menace/worksheetPt1 and c6/menace/worksheetPt2

There has been further work on the MENACE construal here:

  • c6/menace/intro

Some of the above resources are associated with materials generated for C5, which was originally conceived as an embryonic online course: these may be suitable extensions for the online resources described above.

Significant new work has been done by Nick Pope on interfacing the MCE to Arduino. See the reworking of the ten projects from the Arduino starter kit at this link:

  • arduino/projects

A most important aspect of the CONSTRUIT! agenda is determining how best to integrate making construals into the school agenda. The workshop prepared for pupils in Athens at C2 by a small team led by Antony Harfield demonstrated the merits of eliminating the need for window management through simplifying the screen display and making use of worksheet style resources. A 'worksheet' plugin developed by Nick Pope is introduced in this tutorial:

  • tutorials/worksheets

Its application is illustrated in the Triangles worksheet at

  • examples/triangles

Several other construals are currently in development. Some of these are being developed with upcoming events in Athens and at SciFest in mind. A new version of the construal of the CONSTRUIT! project presented at C1 is also under construction. Details will be added to this webpage at a later stage.

The resources developed for the 8th National CAS Conference in the UK in June 2016 illustrate one way in which making construals can be linked to the computing at school agenda.

A review of the MCE developed by Nick Pope during his visit to Comenius University in Bratislava in early in May 2016 can be found at the following link.


Some further observations of interest that could be usefully documented somewhere:

  • if you wish to introduce actions that potentially "go on for ever", it's advisable to do this using when statements as follows:
    i = 1;
    when (i) {

Note that the 'when (i)' clause executes whilst i is non-zero - so potentially executes indefinitely in the above context. The when-clause can still be edited as this doesn't stop the browser from working.