Thursday, November 10, 2011

Capacity Focus, 16: Java Hello World -- first steps towards Computer Programming for all

NB 1: A draft first unit for the course is presented here.

NB2: On the Java hacker attack and issues on using Java
in education in that light, cf. the onward discussion here.

NB3: This thread of thought is picked back up here: 1, 2, 3
(Here is a bird's eye view tutorial, if that's what you want,
& a "for everyone" online textbook can be found here)

One of my deep-set education-and-development concerns is that here in the Caribbean, we are by and large participating in the digital world as consumers [think, music players, cell and smart phone and lap tops etc.], rather than as economically viable producers.

This is worrying in light of the accelerating pace of digitalisation of the global economy.

For instance, consider how in 1997, when Mr Bill Gates bought US$ 150 million of Apple to keep it going (to avoid antitrust suits from the US Dept. of Justice), and Mr Steve Jobs came back to Apple as CEO, Apple had been on the ropes. Jobs initiated a turnaround strategy, and by this summer when (sadly) he passed away from cancer that he did not treat sufficiently seriously fast enough, Apple had become a diversified digital technology company worth US$ 381 billions market capitalisation. This put it second to Exxon, the energy giant. 

Clicks and bits can be very valuable indeed.

And, in an era where a reasonable PC can be had for US$ 300 - 500, where Tablets are looking like (also cf here, here and here) heading for US$ 100 or even less within two years, and where broad-band Internet access is as close as a phone line or a public wireless access point, the crucial resource for that productivity is knowledgeable, skilled, creative people.

Which is precisely the gap we need to address in our region.

The Java SDK Logo (fair use)
I think that a key first step forward would be to develop a simple "computer programming for all" Java-based short course [perhaps, 3 credits equivalent on workload: 135 hours of effort, nominal at 45 hrs/credit]. 

The target is to build a "first exposure" basic computer programming course for the computer literate that would introduce programming using a pivotal language used for all sorts of purposes, from cell phones to web content to creating office productivity applications [e.g. Open Office] and multimedia, and onwards to interfacing and control. 

I note that the Wikipedia summary as just linked says of Java:
Java is a programming language originally developed by James Gosling at Sun Microsystems (now part of Oracle Corporation) and released in 1995 as a core component of Sun Microsystems' Java platform . . . Java applications are typically compiled to bytecode (class file) that can run on any Java Virtual Machine (JVM) regardless of computer architecture. Java is a general-purpose, concurrent, class-based, object-oriented language that is specifically designed to have as few implementation dependencies as possible. It is intended to let application developers "write once, run anywhere." Java is currently one of the most popular programming languages in use, particularly for client-server web applications.
What this boils down to, is that a program written in Java is broken down into a standard format called bytecodes, which can be used locally or transferred across the Internet etc. When it is to be used, the bytecodes are then fed to a software model "virtual machine" that acts like a standard model computer on devices from a cell phone to a PC etc.  The program is then implemented based on the virtual machine. Illustrating:

(Credit: GMU)

This approach requires that, for every device using Java, there is a virtual machine that maps bytecode instructions to the actual physical machine:

A Java Virtual Machine is built to match the actual physical device,
so bytecodes "see"  a "standard"  virtual computer; built in software.
(The bytecodes are in fact the JVM's "machine language.") NB; For
sophisticated control, there are real-time implementations of the JVM.

 But, by introducing such a standard Java virtual machine, code can be written for that, and the gory, ticklish details of matching the JVM to the actual physical device can be left to the expert programmers who designed and built it. (Watch videos here and here if you want more on this sort of thing. [MIT Intro Computer Sci & Programming course sequence videos here.])

That is the secret of the Java motto/principle/ideal/vision, let's call it WORA: write once, run anywhere.

Some of this will doubtless sound like technical gobbledygook, but the bottomline is that Java is used from the cell phone and game console, to the web (where it is very strong), to the PC for office style productivity applications, and in industrial control. (So good is this virtual machine idea that there are now versions of several other computer languages  (even a classic one like Pascal) that write bytecodes for execution on the JVM!)

In addition, in its various implementations -- aka platforms or editions --  Java comes with a rich library of useful modules that give a leg up for highly productive programing with a minimum of donkey-work labour. It is therefore a useful gateway language for developing capacity for digital age productivity.

Hence (balancing the usual concern that a real language is complex and an "educational" one may be simplistic and irrelevant to real world practice), we see Java's suitability on the whole for a "programming for all" course. Also, we need to present an introductory course in a way that is neither naive and simplistic nor overwhelming.

{I add on a later thought from Jun 12, 2012: >> let's broaden and deepen our view, especially given how we now know that there are open source Java Integrated Development Environment [IDE] apps for Android devices.

Before going further, I should note that Python must also be reckoned with.

The Python Logo
That is because of the clean design of this scripting language, because it accommodates structured, object oriented and functional programming approaches, and because of the presence of powerful extensions for math and science, including impressive virtual instruments. Python is probably competitive -- certainly on bang for buck -- with Matlab or MathCad etc. Python is a highly favoured web programming language. It is not to be overlooked that the open source software I have been tracking for animation and non-linear editing, Blender, seems to be Python-based. Indeed, I learned by the way that the local Volcano Observatory uses Python. Numpy, here, Scipy here. And, there is a surging wave of interest that pushes for Python as the first language for intro to programming.

I nearly said, why not just go for Python, then?

Then, it hit me: use both.

Java and Python are not competitors, they complement.

Especially because, given its clean code style, Python code looks a lot like the pseudocode that was popular twenty five or so years ago as the way to lay out structured programs in preference to the older flowcharts. (I ask, am I the only one who preferred flowcharts and -- honest injun -- used them in software design, because of their visual pattern and relative simplicity? [The standard joke was that the code was written, then you went back and drew up flowcharts as a documentation requirement. I hope that is not happening with UML, etc.])

That way, we could exploit the advantages of each, and -- using the Pareto principle of putting in the 20% of effort that gets 80% of results -- equip students with enough to do something useful and "plug-in" extensions to their knowledge base as needed to go on in the areas of interest they have. Then also, we can exploit educational visual programming environments like Greenfoot and educational IDEs like BlueJ or Dr Java, to get reasonably productive fairly quickly. And hovering out there is the Apps Inventor for Android developed by Google then passed over to MIT Media Lab. (Cf a first look, here.) >>

Where it makes sense to also take a Hello World look at HTML (with a few other features), as a good first level markup language (and perhaps as the first Hello World example for the course):

Of course, Java would take pride of place. Here is a "Hello World" for Java:

Of course, dissecting what is in it is a step or three beyond keying it in and running it! But, Hello World is a classic first example that allows us to then see, step by step how such a program works, and then move on to more complex and useful cases. 

Since we are on the Hello World comparison game, let's look at a Python 2 example (cf. vid here):
print "Hello, World!"

Yup, once the internal writing package IDLE (or just Python) is open, that is all it takes. And, of course the line looks a lot like what pseudocode would say. Here is a useful 1 hour intro that is oriented towards the computer graphics industry, one of the places we need to go for digital productivity. But also, in another direction, we have some powerful open source extensions for numerical and scientific computing -- try: NumPy and SciPy -- which are what sealed the deal for me.  Python is also the encouraged language for the Raspberry Pi, though of course that low cost educational computing platform can also be set up to run Java. (Lect course here. Wiki intro here, with links on key extensions.)

Of course, there is quite a debate over the complexity of Java and the suitability of a Hello World as a first program. [NB, cf. here with here and here for many examples.] 

To this, my first point is that -- as we have just seen -- such a traditional programming exercise gives us a fair idea of the flavour of different languages, allowing us to understand what they are like and where they may go.  It also allows us to learn how to set up a bit of code and get it to run on a computer, a skill-building experience that, though basic, is not to be despised.  Then, as the linked discussions suggest, we can go for elaborations. 

The original Hello World can first be modified as an exercise to show the classic programming structures, sequence, branching, decision nodes, iterative do while/until loops; even, cases -- "switch" in Java.  (Cf. nuts and bolts summary here.) Also, of course, to bring out what an algorithm is, how data are organised in arrays, strings and other structures, how coding in a language works with a computer to execute a program, perhaps even some explanation of levels of language from machine code to assembly to high level languages and the different approaches, issues and concerns that have led to the importance of markup, database query and object oriented languages. Certainly, understanding context is a motivation for making effort towards a desirable goal, and gives a framework story-line that aids in recall and understanding.

[[ U/D, April 16, 2013: For instance, consider the following extension of the "Hello, world!" first case study, designed for manual insertion of the number of gallons of fuel and of tank capacity in litres:
/*Our third educational program case will print "Hello, world!"
 * to the console on the screen then will demonstrate decision
 * making and branching with a unit conversion from g U.S. gallons
 * to l litres, tested for capacity c of a given tank in litres.
 * On testing, the program will print an appropriate message,
 * using the if ____ else _____ structure. The next case will
 * introduce the third main structure, looping, to automatically
 * identify the capacity in gallons of a fuel tank of a given size,
 * c litres. (Of course this is using a sledgehammer to crack a nut,
 * and will win no awards for elegant, compact professional style;
 * but it is useful for our current educational purposes.)
public class HelloWorld3{
  // The main method is the entry of the program
  public static void main(String args []){
    //declaring variables, type floating point
    double g; // number of gallons, double precision floating point
    double l; // number of litres, double
    float c;// capacity in litres, single precision floating point
    double e;// excess of fuel over capacity
    //giving values
    g = 11.8;// input quantity of gas in US gallons
    c = 45;// input fuel tank capacity in litres
    //declaring the relationships
    l = g * 3.78541; // converting U.S. gallons to litres
    e = l - c;// finding out if there is or is not an excess
    // next we print the greeting message to the console output
    System.out.println("Hello, world!");
    //this is followed by the conversion and -- if required -- a warning
    System.out.print(g + " U.S. gallons");
    System.out.println(" is the same as " + l + " litres");
    if(e > 0) System.out.println("WARNING: fuel tank capacity is exceeded!");
    else System.out.println("Fuel tank capacity is not exceeded.");
This shows sequences and branching, with use of floating point variables and mathematical expressions. In the next steps, looping can be used to evaluate capacity in gallons automatically, and keyboard input could be used to set capacity in litres. Also, it would be "natural" to introduce an integer variable as a loop iteration counter.  Thus, the three main structures of programming would be introduced.]]

Then, to introduce the objects idea more directly, a more elaborate example can be given that begins to more specifically display the key facets of object oriented programming. When it comes to the "magic words" involved with the main and the System.out, it is probably best to first give an admittedly simplistic explanation keyed to the level of those doing the course that will then be revisited and elaborated as apart of the spiral structure of an effective curriculum

So, from Hello World examples, participants will have learned about different languages, how to use a language to compose and run programs on a computer, and will have in hand a framework for the further focus on the three gateway languages, HTML, Java and Python. BTW, along the way, Java Applets embedded in HTML pages and also Python scripts similarly embedded would be a useful exercise. As will the use of the windowing feature of IDE's such as Eclipse or Netbeans. Since it is laid out as a multi-language IDE, Eclipse may be preferred.}

Now, the idea of doing a Java based Hello World intro to programming for productivity course is obviously a work in very preliminary progress. (Indeed, over a year after putting up the original post, during which it has become the most popular post in this blog, I find myself adding, modding and hopefully improving. Hopefully, we are getting close to something that will fly and soar.)

But, perhaps, course-topics (seeking to be neither unrealistically simplistic or leaving gaps that come back to bite nor going off the deep end) could include:


 UNIT B -- Background Context & Rationale: The PC and other ICCT (Information, Communication & Control Technology . . . adding to the usual "IT" or "ICT," industrial control and web-oriented multimedia) in context, common digital formats for information/data, cracking the box on a hardware and software information systems and networks, to motivate the need for programming for various purposes.
Taking off the lid of a Tower PC: notice
input, processing & storage & output hardware (Credit: Raj)
UNIT F -- A "Hello World," functional foundation for Java- based Programming: Programming, hello world Java Programming, hello world Java (also cf. here for a step by step tutorial approach) and the wider framework of programming by select examples (Dr Java lightweight compiler? BlueJ? Greenfoot? Alice? [Cf. here on Alice and Java etc.] Cf e-textbook here and Moodle online course approach here, also the in a nutshell here.)  Programs as coded algorithms (step by step recipes) and the data structures (& storage) they use, thus the basic I --> P --> O information processing model: initialisation --> input, processing (step by step) & storage, output:
The IPO model, expanded to show units & interactions.
Feedback from o/p to i/p may also be important [especially in
control of systems & processes] (Credit: Wiki)
UNIT 1 -- Building practical proficiency in basics of programming with Java etc:   Programing through instructive simple but not simplistic cases in light of a useful conceptual scheme for the web and for multimedia -- the Applets approach, scripting (Python . . . ), that of Greenfoot and/or Alice with Java, using the objects, actors and actions on a stage. Servlets and client/server applications. Standalone application programs. Illustrative cases, e.g. here, here and here.
UNIT 2 -- What's the buzz about objects and object-oriented programming?: A bit of a quick survey on the objects vs structured vs spaghetti code philosophies (cf. vid here, also useful modelling/design tools).{Since this is a for reference post, it is worth an update June 9th, 2012; to clip Fraser McKay:
 There are certainly some good reasons for using Java in teaching. Firstly, it is object-oriented. It is now generally held that objects-first teaching is better than objects-later. There is evidence that objects-first  students  are  better  able  to  cope  with  solving  real problems  that  their  peers  [7].  Evidence  also  indicates  that objects-early  is  not,  intrinsically,  more  difficult  to  learn  than procedural programming [14] [4].
[7] Johnson, R. and Moses, D. Objects-First Vs. Structures-First  Approaches  to  OO  Programming  Education:  an Empirical Study. Academy of Information and Management Sciences Journal, 11, 2 ( 2008), 95. 
[4]  Ehlert,  A.  and  Schulte,  C.  Empirical  comparison  of objects-first  and  objects-later.  In  Proceedings  of  the  fifth international  workshop  on  Computing  education  research workshop. (August 10-11 2009). ACM, 2009, 15-26. 
[14]  Lister,  R.,  Berglund,  A.,  Clear,  T.,  Bergin,  J.,  Garvin-Doxas,  K.,  Hanks,  B.,  Hitchner,  L.,  Luxton-Reilly,  A., Sanders,  K.  and  Schulte,  C.  Research  perspectives  on  the objects-early  debate.  ACM  SIGCSE  Bulletin,  38,  4  (  2006), 146-165. 

[From: Developing a new teaching language
for use with the Greenfoot platform]}

. . . Ask: what about moving from a virtual to a real stage with say a robot? (This may require creation of a standardised robot emulation package, preferably a pick-place and/or paint or spot-weld unit.)
Evolving from IPO to Objects as a programing paradigm, via encapsulation of data/state/attributes
and methods/functions that act on them in response to messages. Object oriented programs are networks of software objects interacting through messages, and so carrying out the stages of "use cases," i.e. the scenarios or situations that happen when users interact with the system to carry out their own tasks. (Useful 101 here)

. . . {added 12:12:11} where we may then put together a tentative view of how object oriented software can be studied and even designed using the software window approach:

. . . where we may apply the MVC concept, Models, Viewer and Controller to guide clustering of objects to carry out the interface and interaction with the model of the real or virtual object on the stage. In terms explained by Steve Burbeck (originally for working with Smalltalk-80):
MVC process, where the controller
interacts with both the view
and the model. This allows granularity
and isolation of info & components
are loosely coupled, enhancing
maintainability  (Source: Wikipedia)
 In the MVC paradigm the user input, the modeling of the external world, and the visual feedback to the user are explicitly separated and handled by three types of object, each specialized for its task. The view manages the graphical and/or textual output to the portion of the bitmapped display that is allocated to its application. The  controller interprets the mouse and keyboard inputs from the user, commanding the model and/or the view to change as appropriate. Finally, the model manages the behavior and data of the application domain, responds to requests for information about its state (usually from the view), and responds to instructions to change state (usually from the controller). [Applications Programming in Smalltalk-80: How to use Model-View-Controller (1987 & 92)]
. . .which brings up the complementary DCI paradigm. (Cf here, here, here.) That is, data-context-interaction, which can be adapted to our purposes. In effect we can go back to the stage metaphor above. In a play, actors come on-stage, and carry out roles that they have been prepared for (i.e. they have personalities, responsibilities and relationships), in scenes, within the context and flow of the overall play, which moves from a beginning through a process that reflects some perspective on reality, and leads up to a climax and conclusion. Let the actors now become objects with states specified by relatively stable (but modifiable) data. Next, bring the objects together in the context of a relevant scene (use-case) that is related to the need and understanding of the relevant user.  Then, permit a scripted interaction, to move from the initial status to the desired end, which may lead on to other transactions with the user, etc. (It helps to think about say an automated teller machine transaction, or a manufacturing process with an industrial robot and a workpiece.) This brings up the idea of a scripted context object (and story-board!) that brings together role objects and gives a specified pattern of interaction, providing cohesiveness and a "home" for the overarching step by step process or algorithm -- "method" -- by which the user's desired procedure is carried out on the stage seen in the software window:
DCI in action, showing how a context object can bring together role objects to interact according to
a script on a stage. The MVC context is also evident. In effect the context object provides cohesive and intuitively familiar context in which roles can be played by relatively simple and static role objects with stable but developing personalities (that is, internal states with associated methods). While this is often presented in the context of moving the overall OO approach towards a more dynamically typed approach, the provision of a scripted context as an umbrella software service to the role objects that are naturally involved in a scenario, plausibly provides a valid solution strategy. At least, this is arguable in light of the software window vision of OO programming. (Source: Trygve Reenskaug and James O. Coplien, The DCI Architecture: A New Vision of Object-Oriented Programming, 2009)
. . . so, we can consider the different ways in which a system can be used by different users (actors), which sets up the significance of the UML  (= unified modelling language, cf. video tutorial) use-case diagram [which can work at different levels of details up to the very broad way to interact with a system], and associated storyboards for the flow of activities for each detailed use case:

A system-level use-case diagram for a web based broadcast system, with use cases in ovals, packaged sets of cases in sytlised folders with tabs, the system being within a box that marks its boundary, and with users being represented as stick figures. [SOURCE: Visual Paradigm, which gives more details. Ambler's discussion here is is also helpful. The breakout to the system modelling perspective is helpful, cf here on SysML (explanation here, reference card here), a system modelling language linked to UML.]

. . . which brings back an updated form of the old fashioned flowchart, through the  state and/or activity diagrams, including as a way to lay out the algorithm that effects a method. In UML 2.x, activity diagrams are based on Petri Nets, allowing them to capture workflows and process logic, i.e algorithms [finite, step by step procedures that move from a start to an end state, and often solve a problem or carry out a composite task, nb the concept that programs code and organise algorithms to act on data in structures to effect desired solutions]:

In this activity diagram for brainstorming, the start-point is a filled circle and the end point is a similar circle with a ring around it. Activities are in rounded rectangles, decision nodes are in the traditional diamonds, with alternatives in square brackets. Concurrent clusters of activities start (split) and end (join) at bars, with arrows showing the flow of the activities that lead to the end state. The overall block is joined in a labelled enclosure and sometimes the chart can be broken into "swim lanes" that show parallel chains of activities. (Source: Wiki, cf Ambler here and here.)
 . . . and where also how such role and context objects specifically collaborate on the stage to carry out a programming/ user/ business step by step task or process can then be illustrated using a UML sequence diagram, e.g.:
A UML sequence diagram, with actor/operator and objects interacting to carry out a task, by interacting through messages. The use case diagram allows us to study typical scenarios for the required behaviour of user - system interactions, the sequence diagram helps us see how software objects work together to do this, and the class diagram shows how the classes of objects identified are structured together, thus allowing the software network of objects to be assembled in code as a program. (It is helpful to apply the Pareto 20/80 principle -- 20% of a program's capabilities/features covers 80% of real world cases and effects, so an effective approach is to focus the core program on the pivotal 20%, and then to put in customising plug-ins to cover the odd cases; allowing for flexibility and customisation. It is often wise to allow for third parties to develop plug-in widgets that extend the function of the core program, and to share them in an exchange. [Background on Pareto here.]) The deployment diagram shows how the network of objects is put together on the ground in the actual system to be built. Other diagrams are also useful. (UML is a subject to itself, cf overview here, "cheat sheet" here, and more on seq'ce diags here.) (credit: Sanchez; pardon fuzziness.)
. . . where also, a system-level sequence diagram can be particularly useful in analysing, understanding and  developing key interfaces between major units in the overall system in view, e.g.:
A system level sequence diagram, showing the user interface. From this level of analysis
across use cases and scenarios, the required cluster of units on the stage can be
identified, and the projected software window interface. More detailed sequence
diagrams would help identify the interactions between units, and onwards helps in
creation of a cluster of relevant classes and objects, the classes being blueprints
for objects. In praxis, reference will be made to the library of predefined classes
in the programming language's Applications Programming Interface [API]. Also
cf. detailed development here, starting with hand drawn examples and bringing out
how system level interfaces, background services and methods can all be analysed
and developed through the sequence diagram technique, leading to OO programming
 . . . such gives a context for one of the key UML constructs, the class diagram (summary here, cf. also here, here) which displays an overview of blueprints for the software objects, showing their relationships (and by extending to a fourth sub-box, perhaps role responsibilities) and so the structure of the system under development:
Classes displayed by relationships, showing in this simple example, derivation of sub-classes that extend a more generic class and also displaying many to one relationships. Each class -- a blueprint corresponding to the actual objects to be used -- shows name, state-defining variables giving attributes, and methods required for roles (which can be listed in a separate box, but it may be more effective to use CRC cards and/or ORM diagrams) [Source: Tutorialspoint. NB: OO Programming is an approach that centres on objects, and the class diagram shows abstraction and inheritance: a generic super class allows sub classes (and onward objects) to be created by inheriting the core structure, then extending it for particular specific uses. In extension, variables (so, state data) and/or methods may be added, and in some cases what was inherited can be over-ridden. Encapsulation means that data and methods are hidden to outside objects, there is only message-passing to an interface, allowing for granular modularity and reducing the tightness of coupling of modules. Polymorphism follows: by using generic messages, the particular object responds in a particular way to a given message based on its data and methods, e,g a request for colour may return green, blue or violet. ]
 UNIT 3 -- Ballistics simulation as a first case study: A case study: creating a simple simulation or game -- no shoot-em-ups, please (maybe, a robot emulator or a drip irrigation for a plant nursery?) As a first step, creating a windowing environment based projectile simulation, first the ideal ballistics case then the case with air resistance. Then, a look at what is required for more advanced and relevant simulations, games and controllers.
UNIT 4 -- A cluster of possible simulations/games: Developing a realistic program for a significant situation, as a case study.  [Here is an old applet based robot simulation. This is a position-arm robot simulation. This is another [Javascript?], downloadable.] -- for a PC or a smart phone like device, accessed via web technologies. Here is the Garduino setup for a garden drip irrigation controller:
A lab scale garden controller. (Credit: Luke Iseman.)

UNIT 5 -- Introduction to & preview of real-world, real-time interfacing and control: using ports and addressing the responsiveness issue for control. Discrete state control vs control of dynamical systems (the leaky tank with level control in light of of inlet and outlet as an example; perhaps making reference to the float-ball control of water level in the tank of "our friend John" in the bathroom). The issues of control in real-time -- how much latency in response is acceptable [the 4 - 6 samples per rise time rule of thumb], how predictable is the processing time for control responses, how reliable are communications [the widely distributed SCADA case], the issue of collapse vs degradation of control if the real time constraint is missed: hard vs soft real-time systems. The need for direct access to hardware memory or input-output space to deal with sensor and actuator interfaces, memory mapped I/O vs I/O space vs direct memory access, interrupt handling and latency, threaded programs and concurrency so the possibility of loss of integrity of an otherwise valid algorithm, memory garbage collection issues and latency, etc.  Hosting of modules in languages that more easily address such challenges vs real-time Java implementations. Industrial PLCs, field buses [e.g CAN] and safety challenges and regulatory requirements to be life safe, etc.
UNIT 6 -- Developing a case study: simple drip irrigation control for a garden/shade house plot; this being a discrete state controller tolerant of considerable latency. (Cf. Iseman.) Such might be supplemented with a level controller on a feed tank [to maintain steady pressure in the feed lines], perhaps in turn driven by an input line from a rain water cistern.

UNIT 7 -- A further possible case study: a simple robot arm (emulated?) with a preview of what a full control system would require.
UNIT 8 -- A third possible case study: a simple multimedia exercise (gaming? [cf. Python-based pyglet exercise here])
UNIT 9 --Setting up and carrying out "simple" Projects: Projects (research, coding, emulation, interfacing) and evaluation.

UNIT 10 -- Epilogue: Where to go from here.
You will notice that I am moving beyond IT and even ICT to "ICCT."

That's because I am building in a bridge to industrial type interfacing and control, as we need to cross that bridge to create a new order of industrial development in the Caribbean. 

{Added, 12:12:01:  And in terms of a physical facility, we could do some version of a multimedia seminar room similar to a prototype developed for a regional university unit, at the turn of the 2000's. The development of LCD screens and thin client networks makes this very do-able for a church hall or community centre computing facility or even a room at the district post office. Indeed, something probably could be done along these lines with a couple of 40 ft containers put side to side with the inner walls taken out and a roof put on, with some sheet rock or thin ply panelling:

if you want to look at a real world case from a major university, here is a similar lab from (IIRC) Duke University:

In short, we could do something like this almost anywhere where we have broadband net access, to give the Web interface. And, I am sure something can be adapted for cases where that is absent, by creating a local network and information reference server, perhaps even with a local digital library.}

Is this or something like  it doable?

I think so.

Why not let's watch a Hello World video, then think on it together:

(See how a video can make a difference to how a course could be implemented? See the advantage of web-based, multimedia and interaction oriented courses? I also strongly believe that we need to bring knowledgeable facilitators and students together on the ground in the local community, hence the idea of a network of micro-campus centres joined in a web based network, and organised on a networked college basis. In particular, I think every church or community centre with a phone line and a room of adequate size could become a microcampus centre. If we do this, we could instantly have the largest college network across the Caribbean.) 

{U/D 12:12:01: Where, once something like a programming and multimedia productivity certificate leads to creation of such a network, other components of an envisioned Associate Degree programme can be added, probably with an emphasis on part-time delivery. A certificate for agriculture for all integrated with something like the european-style traditional gardening allotment schemes would be helpful, too. Perhaps, something like the Schools of Hope, Haiti idea could help. Where also, something like a graduate certificate --> diploma --> Masters package could be used to create a piggyback Masters in Education. (This would serve to provide capacity strengthening for the proposed Associate, and could also provide a much broader in service upgrade track for teachers.) A similar approach could also be used to facilitate a franchised Masters in Business Education or Public Administration or the like also. Integration with a regional network of campus based programmes would then allow a much wider capacity to access education starting in communities where one is living and working. That is, the interest in digital technology can be a flagship and gateway for a more complete discipleship, education and capacity development based, strategic community transformation endeavour.}

So, what do we think about this sort of idea? Any volunteers to build Java case studies of programmable leaky tank, robot arm and drip irrigation garden plot emulators? Could Greenfoot or Alice do this? END

No comments: