The redundancy within the code is reduced / the size of the code may need to be larger, but it's quite neat. I'm continuing to study the subject / look for a library that I can use within our website using existing server setups - and certainly I'll be doing demos to people on our courses even though I've nothing in an openly publishable form yet.

• Is your child's school bag harming their spine?

• Happy Pills can make you more depressed

• My beloved chocolate gave me ulcers and heartburn

• Why did one of these twins have to die before their cough was taken seriously?

• Moggie lovers beware! One bite from a cat can put you on the critical list

• Girl dies of TB 'after being told she had bulimia'

• No candles - Safety Police ruined my son's 3rd Birthday

• Children planning a gap year? Read this deeply worrying story before you wave goodbye

• Why mid-life health kicks can WRECK men's bodies

Are we living in a more dangerous world, or is it just a slow news day?

Over the past 6 to 8 weeks, I've been helping to enhance the diary pages on the Melksham Chamber of Commerce's web site, adding in special events and things that are happening in the Melksham Community Area. Part of that enhancement has been to monitor the number of people who have been reading the diary, where abouts they're located (are they local or not?), and whether they're returning visitors / regular users of the diary, or just "single hits".

On average, we've had ten different visitors to our diary every day from Melksham or from nearby towns. Within that same day, two or three of these visitors typically come back - and we're looking 'later in the day' here, not simply clicking back to the diary!

Taking a longer view, over 420 visits by over 270 different people have been made to the diary in the past month - that's a significantly higher proportion of repeat visits, and it shows that people are making a habit of coming back to see what's going on. Only 1 visitor in 20 is from outside the UK, again showing the quality of the traffic as it fits in with the metric of most trader's customer bases. There is bound to be some "noise" ... and we do get quite a few overseas visitors in Melksham; no great secret that we often have folks in at Well House Manor from overseas - the USA, Switzerland, Germany, and even China in just the last few weeks.

Inclusion of your event in the Chamber of Commerce diary is free. It covers events which:
• Run up to ten times a year
• Are open and available to the general public / guests
• Take place in or effect the Melksham Community Area
Commercial, Voluntary and Charity events welcome. Public meetings and talks welcome. Council and board meetings too.

To view the diary, see [here]
There's also a version for your mobile phone [here] (and visits there aren't even counted in my stats)
And to add an entry for YOUR event, go [here].

Here's Phil - who's the curator of the collection - showing our Town Crier and an early arrival some of the artefacts and electronic information we have available. Melksham has existed as a town since Saxon times, and although our current exhibition theme - based on travel and transport - primarily covers more recent times, we've got a huge and proud history to reflect. With only limited space, and many of the photographic originals being in private collections and not suitable for repeated handling, much of data is provided by computer screen. And it turns out that scanned photographs, enlarged to fill the screen, reveal far more than could be seen by the naked eye in the original.

We had an ideal flow of visitors all day yesterday - no big crowds to flood us out (so no need to call in the contingency plan!), but on the other hand we were kept on our feet, and interested all the time. I only got the time out to get a few photos, as most of the time was spent talking with guests, directing them, and listening to them tell us more about this fascinating town.

You'll see that all the artefacts in the collection are carefully labelled (and they're catalogued too) - much hard work behind the scenes in recent weeks by Lisa and Phil. And the cataloguing system continues. We've been loaned a number of artefacts - nothing of any astounding value, but may unique / sole examples, and it's critically important that we take care of them, know which belongs to whom, and the detailed terms of the loan. By having such a system in place, we've already been entrusted with a number of very interesting things - some on display, others which have been photographed and returned already.

Melksham has changed a great deal since the coming of photography, and will continue to change. The King's Arms and the Church in the town are still recongisable, but some scenes are not. And although the museum looks at tha past, it must also look to plans for its own future. Wouldn't it be wonderful to have museum / exhibition space in Melksham's new Campus - to be seen and celebrated by many thousand visitors evey month, and to draw in people from outside the town to look not only at the exhibits, but also to use other Campus and town facilities too. Truely, the museum can use th epast to help us build for our future.

And so - my last picture from yesterday is the first taken - before we opened, showing the mix of the old and new technologies to bring history to life and to the people of the town. Please do come in and see us - the museum and current exhibit are open every afternoon from 2 p.m. to 5 p.m. at Well House Manor on Spa Road, Melksham. There's so much information that we have in the computers that we can only provide a glimpse - a tiny proportion - via our web sites and the internet - you really need to come in. And when you do so, please make sure you allow plenty of time to stop and enjoy a strawberry cream tea too.

We finished yesterday tired but happy - indeed, so tired that I fell asleep before I got a chance to write up the day. And to say "Thank you" to Phil, to Lisa both of whom who've put so much into this ... and to everyone else too. I started writing a list - and it's a very long one. To those who have provided us with encouragement, artefacts and memories. To the press who have helped us get word out about our launch (and will continue to tell people our success story, I hope). To those who came along on the day - in both official, supportive and unofficial capacities. To the members of our own staff team who were on hand yesterday and will be on hand today and in coming days. And to our visitors, without whom the whole thing simply couldn't work.

In Lua, you can hold a whole bundle of information about something in a table, which gives you a convenient "handle" to that information - be that information in the form of values, or behaviours (i.e. conventional variable of code). This is illustrated in earlier articles on Lua Tables and on Using Lua tables as objects.

Let's look a stage further. As well as unique pieces of information associated with a particular table / object, you'll want to have common members - pieces of code that run on every table of a certain type (in OO terminology, that's methods that can be run on every member of a class). And this is where Lua Metatables come in.

A metatable is itself a table that contains variables and code. It can be linked into / called up from any other table (a parent table, if you like) by using the setmetatable function. And once that metatable has been set, references made to members that do not exist in the main (parent) table will be passed on to the metatable. This isn't actually a one-to-one mapping - making it a bit harder for me to explain, but much more flexible when I come to use it.

Let's take a look at the standard behaviour of a table:

  function newtrain(length) -- set up objectish table
    local newone = {}
    newone.cars = length
    return newone
  end
  
  southampton = newtrain(2)
  cheltenham = newtrain(3)
  
  print (southampton, cheltenham) -- just prints address

And here's the output:

  munchkin:lm12 grahamellis$ lua kitten
  table: 0x100106bb0 table: 0x100106c20
  munchkin:lm12 grahamellis$

Sample code - [here]

How do I create a Metatable?

Let's now say that I want ALL the tables created by the newtrain function to print out nicely, and I also want the abiity to define how to add such table togethers. Rather than define all the extra functinallity lots of times, in Lua I can define a metabable and then say (in a single call for each of my parent tables) that the train tables all behave in the way defined in my metatable. Let's take a look at how that works:

Firstly, I'll create a table (just an ordinary table) which I'm going to use for my additional functionallity.

  demo_metatable = {}

I'll then add some code that's to be shared to that table:

  function demo_metatable.__add(this, that)
    local newone = {}
    newone.cars = this.cars + that.cars
    setmetatable(newone, demo_metatable) -- so that we can piggyback additions
    return newone
  end
 
  function demo_metatable.___tostring(this)
    return "A train of " .. this.cars .. " carriages"
  end

And finally I'll call up that table in my newtrain function as its metatable

  function newtrain(length)
    local newone = {}
    newone.cars = length
    setmetatable(newone, demo_metatable) -- so that we add them
    return newone
  end

How do I use a Metatable?

Any tables that I now create via the newtrain function will be "tuned" with the features of the metatable called demo_metatable ... adding together two tables (using the + operator) has been defined as producing a new table with "cars" members added, and I've also defined how to print such tables.

So I can now write some code to use these functions and the metatable:

  southampton = newtrain(2)
  cheltenham = newtrain(3)
  service = southampton + cheltenham
  print (southampton, cheltenham, service)

and the behaviour is modified by the __add function so we don't get:

  lua: tabby:27: attempt to perform arithmetic on global 'southampton' (a table value)
  stack traceback:
    tabby:27: in main chunk
    [C]: ?
  munchkin:lm12 grahamellis$

but rather an addition is performed, and our printouts saying:

  table: 0x100106c20

are replaced by the output from __tostring:

  munchkin:lm12 grahamellis$ lua tabby
  A train of 2 carriages A train of 3 carriages A train of 5 carriages
  munchkin:lm12 grahamellis$

Sample code [here]

Adding elements of other names to a metatable

What if I want to add another name of my own choice to every table of a certain type? I can do it, but not directly by adding that name to the metatable. Instead, I have to provide a function called __index in the metatable, which can then branch out and act as appropriate.

So if i want this to work:

  for _,v in pairs(options) do
    print (v, v:getlength(), v.bums, v.capacity, v.earlobes)
  end

I might add the following to add the required extra definitions to the metatable:

  function demo_metatable.__index(whichmaintable,whatcalled)
    if (whatcalled == "getlength") then return demo_metatable.glen end
    if (whatcalled == "bums") then return whichmaintable.cars * 73 end
    if (whatcalled == "capacity") then return math.floor(whichmaintable.bums * 1.4) end
    return "teabag" -- default
  end
  
  function demo_metatable.glen(source)
    return (source.cars * 23)
  end

Sample code [here]

Two pictures of Melksham station (roughly from the same spot), dated "Circa 1940" and Friday, 11th May 2012.

There are many more old pictures of Melksham, and new pictures too, on show in the Well House Collection - a museum for Melksham - which opens its doors at 11 a.m. tomorrow - that's Saturday 12th May 2012. It'll be open all day, then every afternoon all through the summer. Location - 48, Spa Road, Melksham. Artefacts as well as pictures. Free entry, free parking ... but please stop long enough to buy a bean-to-cup coffee or a strawberry cream tea.

See [here] for the museum website.

Those of us who have been involved with rail for a while have heard talk of the "7 day, 24 hour" railway. Alas, that remains just a pipe dream - an aspiration - and I was rather forcibly remined on that by a request in my mailbox overnight:

For the last 4 years I've run the BUPA 10000 in London..... for the first 2 driving up and making a weekend of it and the last two going up on the 07:00 (or near) train on the day just for the race. This year the earliest train from these parts seems to arrive at 09:45 which is no good whatsoever as the race starts at 10:00. I'm wondering if there's a cunning way of getting there earlier? Race this year is Sunday 27th May (Bank Holiday weekend).

Perfectly reasonable requirement, you would have thought.

The first train from Chippenham runs at 08:10, which is scheduled to get into Paddington at 09:44. Even by driving up to Swindon, you'll catch the same train and only get to London at 09:44.

How about the next line to the south - from Westbury or Pewsey? Lazy daisies over there - first train out of Westbury isn't until 09:41, getting to London at 11:29, by which time the race is probably over. How about from Bedwyn, the extreme of the London suburban service which just pokes its nose into Wiltshire? Oh - the first train from there doesn't run until 09:51, getting to London at 12:22 having had you on a bus for part of the way!

Of course, I (and my correpondent too) live in Melksham, a town of some 24,000 people. Our Sunday train service is totally inappropriate for days out on a Sunday. First train is at 17:25, with a connection that gets to London at 19:26. Frankly, the service we're offered on sundays this summer is an insult. Whilst slightly late for the BUPA 10000 race, last year's 07:45 departure getting into London at 09:44 was a fantastic (and much used, even in 8 weeks) facility that should at least have been offered again this summer, and really should run on every (52) sunday in the year.

My correspondent asked about a "cunning plan". There are earlier trains on South West Train's line in the south of the county - from Salisbury, there's a train which gets to London at 08:19 - a full hour and 20 minutes before First Great Western wake up and provide a service from Wiltshire; what a pity it's a huge dogleg from Melksham to go via Salisbury and (of course) there isn't an early train from Melksham to Salisbury - in fact the first train there isn't provided until 18:44

What a tremendous scope we have for improvement to something much more appropriate for our needs in the next franchise!

A business visitor is coming to see us from the Bristol direction on Tuesday. She's looking to arrive in the town at around 09:30 (and happy to be an hour or so earlier or an hour or so later), and she does not drive. We don't know how long she'll be with us - best guess is about 4 or 5 hours, so ideally she'll want to return at around 3 p.m.

Bristol is a major city; Melksham's a town of some 24,000 miles just under 30 miles from Bristol, and within Bristol's natural catchment - so this should be easy enough - an hour's journey at the most, right? WRONG!

She'll need to leave Bristol Temple Meads at 05:44, change at Trowbridge (42 minute wait) to reach Melksham at 07:19, as the following train doesn't leave Bristol until 18:30 for a 19:10 arrival in Melksham (to prove it CAN be done in 40 minutes!). For the return journeys, there's a train at 19:11 and another at 19:48, both taking under an hour. Rather late for that 3 p.m. departure, but those are the first trains after 07:20 in the morning! Using the bus, the journey of 30 miles from Bristol takes 99 minutes each way.

Our Monday to Friday public transport service is totally inappropriate for business visitors to our town.

The train services that we currently have on the TransWilts line that provides the service to Melksham (and from other West Wilts towns to Chippenham and Swindon, and betwen those places and Salisbury) may have been adequate ten years ago - but now they're woefully inadequate and that has a serious negative effect on the economy of the area the line serves.

The current franchise, operated by the First group, runs a service level that's based on usage figures that are now ten years old (and even then were depressed by a lack of trains) and assumed a growth rate of 1% per annum. Contrast that growth rate to the growth actually experienced in West Wiltshire over the past decade:

and you'll see that the figures for train use have nearly doubled - the growth rate's been something like ten times the rate predicted, which was broadly in line with population growth. Plans simply didn't allow for the modal shift to rail that's happened, and continues to happen.

Graph presented at a public meeting in early April in Trowbridge by Richard Gamble, Portfolio holder for public transport in Wiltshire Council and reproduced with his permission.

What's needed for the next franchise period, then? Services all day, every day. People will move their journeys forward or backwards by an hour, but not much more - so that's a train every 2 hours. This appropriate service level has been tested as an economic case - it passed with flying colours. For operational feasabiity - it passed with flying colours. In a business survery - it got excellent support. In a public survey - support is massive. Even in a trial service last summer - which was so busy it's a victim of its own success this year.

But I do one further samity test. I real travel requirements I hear of, such as the two at the top of this article, and I measure them against the service that's being asked for. I ask "would the requested service meet the requirement". And I get the strong answer, again and again, YES, it would.

Please ... can we have this well researched and appropriate service in the next franchise?

There's a new example of this [here] on our web site, from yesterday's Lua Course.

I created a series of "archive access objects" from our web server log file, where each object is a blog archive request to the server. The code to create each object (and add it to a table of such objects) is:
  pages[#pages+1] = archive.new(num,nam)
and I then looped through all members of the table or archive objects, printing out their details:
  for _,access in pairs(pages) do
    print (access:getnum(), access:getnam())
  end

As ever with object orientation, the clever stuff is hidden within the class - in this case the archive table which I defined to hold a piece of code called new. new sets up a new table each time it's called, into which the data, and also a reference to functions getnum and getnam, are stored.
  archive.new = function (index, title)
    local current = {}
    current.index = index
    current.title = title
    current.getnum = archive.getnum
    current.getnam = archive.getnam
    return current
  end
(the originals of getnam and getnum are stored in archive purely for convenience)

Rather than copy all the methods across into each object, Lua includes a facility called metatables that I'll be going on to look at during today's course ...

Opens 11 a.m., Saturday 12th May 2012, at Well House Manor, then every afternoon through the summer.

Well House Manor is on Spa Road (the Devizes road from Melksham's market square), a few hundred yard from the centre of town. Free parking on site. Coffees, teas, cream teas available daily. Please do pop in and have a look!

I can set up a table like this:
  occupancy = {2,5,5,3,2}
which will set up a Lua variable called "occupancy" with five members, numbered 1 to 5, with values 2, 5, 5, 3 and 2.

I can then reference the values by their position, using square brackets:
  print (occupancy[4])
will give me the result 3 since the fourth element - element number 4 - contains the value 3.

I can change values, for example:
  occupancy[4] = occupancy[4] + 2
and even extend the table by adding another element onto the end
  occupancy[6] = 4

I can use a variable to refer to a the position number in a table too - thus:
  k=2
  print (occupancy[k])
will give me the result 5 as that's the value in the second position (position number 2) of the table.

By using a # sign in front of a table, I can refer to the number of elements in a table - thus I can write a generic piece of code to extend a table:
  occupancy[#occupancy + 1] = 2
and I can loop through every member of a table such as the one in the example I have used so far using a loop:
  roomnights = 0
  for k = 1,#occupancy do
    roomnights = roomnights + occupancy[k]
  end
  print ("You have a total occupancy of "..roomnights.." room nights")

And I can set up an empty table like this:
  another = {}

In the example above, I've only stored numbers in my table (in Lua, all numbers are actually double precision floats, so there's no "integer v real" question to address). But I'm not limited to that - I can store anything that I can store into a regular variable into a table, including:
• a number
• a string of text
• a function (a callable piece of code)
• another table
and I can even store different types of data into different elements of the same table.

There's an example from the course notes - showing what I've talked about above - [here].

So far, I have used position numbers starting from 1 within my example tables - and so it's been rather like a list if you're familiar with Perl, Python or Tcl, like an array if you're familiar with C or PHP, or like a vector if you're familiar with C++ or Java.

But in Lua I can go further and use named elements in my table. That will mean I can compare with a hash in Perl or Java, an associative array in PHP, a dict in Python, an array or a dict in Tcl, etc. Let's see how that works:

Setting up a table with named members:
  roles = {chair = "Sion", treasurer = "Chris", secretary = "Phil"}
adding on more:
  roles["vicechair"] = "Peter"
  roles["press and publicity"] = "Graham"

I can then access individual members using the key name:
  print (roles["secretary"])
or indeed using a variable which contains the role name:
  contact = "press and publicity"
  print (roles[contact])

If I re-use a key as I assign a value, I'm replacing a member (cell) of my table. If I give a new key, then that will add a new member to my table:
  roles["supporter"] = "Dominic" -- adds new then ...
  roles["supporter"] = "Roger" -- replaces that value

When I had numbered elements I could easily loop through my table, but now that the elements are named, I can't simply write a loop in quite the same way as the names are unpredictable. However, I'm provided with a function in the Lua standard implementation called pairs which lets me loop through all the key / value pairs of a table so that I can perform an action on each of them in turn:
  for k,v in pairs(roles) do
    print (v .. " is in the role " .. k)
  end

results:

  Sion is in the role chair
  Graham is in the role press and publicity
  Phil is in the role secretary
  Roger is in the role supporter
  Peter is in the role vicechair
  Chris is in the role treasurer

You'll notice that the order is unpredicatable (and certainly not useful) and this is because a "hashing algorithm" is used, which makes it very fast to access individual elements, but impossible to sort them directly into any form or order.

I can delete individual members by setting them to nil, and I can delete an entire table by setting in to nil.

An alternative notation for table members allows me to replace the pair of square brackets for a named member with a dot - you'll see this commonly used, and forming an object-like approach in the process if you're familiar with object oriented programming. Thus
  print (roles["vicechair"])
  print (roles.vicechair)
use different syntax to mean exactly the same thing.

There's an example of a table with named members from our course material [here].

On yesterday's Lua Programming Course, this was the point we got to in tables. There's an extra colon notation to cover yet, and the whole big subject of metatables ... something for me to come back to later today - or you can find some examples already from the course notes and previous courses via [here].

The final example from yesterday is [here]. We put together string handling, file handling and tables to produce a useful piece of code which reads the records in a file, etracts some key / value pairs from selected columns, and stores all of the pairs which meet certain criteria. Once the table has been set up, our demonstration simply prints out the whole table, but we could go on and extend the application to do much more. In fact, I'm sure we'll start today by sorting the results - it's not directly possible, but indirectly it's very easy indeed when you know how ;-)

Lua is an open source language, with a very open license indeed which allows it to be incorporated into other products without raising complex onward licensing issues even if the resultant product isn't itself open source. So this makes it rather good for incorporating into software such as computer games to provide a tailoring interface for knowledgable users. It has small footprints too, and again that makes it rather good for building into other products, especially where those other products may be running on smaller systems rather than meaty server computers. Paradoxically, the smaller footprint means that some things are left out of the language - features which are in a standard library routine in Python or Tcl need to be coded from first principles in Lua, or downloaded from another library / source, or built into your own library. Which makes learning the smaller language a slightly bigger task - I say "slightly" because Pareto's Principle - the "80:20" rule applies - Lua's a langauge that's less that 20% of the size of others, but actually does well over 80% of what most people want to do with it.

Delegates coming to Well House to learn a programming language come with two different backgrounds. The first group comes with some prior programming knowledge, and is looking for something of a "conversion course" - there will be things that are different from the langauges they already know, but principles such as naming memory elements ("variables"), conditionals, loops, and named blocks of program ("functions") still apply. The second group comes without any prior programming experience, and so they need to learn these principles as well as the language itself and how they're implemented in the language.

How do we handle these two different starting points / groups on our courses? We can't just run a single course. It would EITHER be far too slow for those with prior experience OR it would be far too fast for newcomers to programming. But with some of the niche subjects we train in (Lua, Tcl etc), it wouldn't be cost effective to run two completely separate courses. So here's what we do:

• Newcomers to programing join us on the first day for "Learning to program in XXX" - an easy introduction to the priciples of variables, loops, conditionals, data types, etc, presented in the programming language that they'll be learning all week. This day starts with a blank canvas - no book of "here is one I wrote earlier" examples, but rather with clear explanations from scratch, importantly showing delegates not only what a particular program does but also - and much more importantly - how to write such a program.

• Delegates with prior programming experience join us on the second morning. A much faster introduction to variables, loops, etc for them - showing too how they differ from the other languages that those delegates know - acts as a re-inforcer of the principles learned on day one by the newcomers to programming, and the course can then carry on with both groups working together.

Every delegate on our courses who have prior programming experience was once a complete novice, so those delegates joining us from day two have a tremendous appreciation of what the "day one folks" are going through. It extends beyond sympathy - it means they can and will provide truely interactive help during practical sessions. And it means they'll be challenged to explain their own understanding of first principles - a big gain for them in making sure that their groundworks are correct and secure too as we go on through the course.

Our formula for training both newcomers to a language, and newcomers to programming, works in such a way that both receive an excellent course. Today is the second day of "Learning to program in Lua" and the first day of "Lua Programming". In about an hour's time, I'll be talking about the principles of variables again, but this time with a slighly more technical slant to paint a slighly deeper picture for yesterday's delagate, and to highlight the differences between Lua, Java and PHP (I'm pre-altered to prior knowledge in my group of those two) for those who are converting.

From yesterday's course ... I've put the examples online for the delegates to refer back to later:
• Simple program - read keyboard, calculate, output result in Lua: [link]
• Adding in a condtional test - [link]
• And with a loop, producing a whole series of outputs - [link]

Please follow the course links in this article to read full course descritpions, and find our current schedule of dates, prices, and our location. As well as public courses, we can run private courses at our training centre, or on your site if you have a larger group who require the same course at the same time.

Then onto Salisbury, with their picture taken to prove their presence here. Very odd to find those cafes that were open were bursting to overflowing, and yet many places - and the Tourist Information Centre - were closed. You would have thought that Salisbury would have learned the balance over the years, but it was good to see it busy in stark contrast to Melksham earlier in the morning, where the TIC was also closed.

Even the wet weather hadn't dampend the beauty of Wiltshire - the newly-cleaned Westbury White Horse on our way home. And what a joy to be showing guests around to whom the country was so new - to whom our verant greenness was an excitement, and who delighted in the grass and tree, horses and cows, ducks and swans in Salisbury and the glorious old buildings> They tell me it's very different to Guangzhou

There were lots of twains wunning by today - the main Bewks and Hants line being closed for wepair. And a beautiful cloudy sky.

This last week, The Sun got itself into twouble by picking on the new England Football Manager's pronounciations of "r" as "w". Hmm ... it's just a way of speaking - he wouldn't make a speech thewapist but that's not his new wole. (And neither would I, for I have the same thing), but it needn't hold him back

Trowbridge doesn't have the best of reputations, but beside its waterways it's bustling, and we look forward to waterway improvements in Melksham

The pictures are scaled down on the live blog. Click [here] to see the archive, where they're 9 times the size.

• A good programmer is a lazy programmer, who won't want to redo work that (s)he has already done.

• A lazy programmer is an efficient programmer, as that means better use of development time

• A program that was efficient to write because it only includes each piece of logic once is also an efficient program to maintain through its life. There's only one place in the code that needs amending as requirements are updated, or where unplanned circumstances need to be accommodated

How do named blocks of code work?

You'll come across words such as functions, subroutines, macros, procedures, commands, macros, methods, defs callable objects and perhaps a few more, and they all follow similar principles

1. In your program, you define one of these blocks of code and you give it a name. They syntax will vary from language to langauge.

1a. Within the named block, you will make use of a number of parameters - values which are passed in to the named block for it to operate on.

1b. At the end of your block, you will provide a return statement or value, which is the result that's provided to the calling code.

2. Within your main program, you will call the named block.

2a. You will include in the call which values are to be passed in at that particular place when it runs.

2b. You will take the result that the named block returns and save it to a variable (or test it, or perform further logic on it) in your main program.

Here's an example in Python. Firstly - the definition of the named block:

  def capacity(seats_per_vehicle, vehicles):
      total_seats = seats_per_vehicle * vehicles
      cap = int(total_seats * 1.4)
      return cap

Then an example of its use:

  hs125_v = 8
  hs125_spv = 65
  london = capacity(hs125_spv,hs125_v)
  print "Capacity to London is",london

And another example of it use:

  todays_length = int(raw_input("How many vehicles on the TransWilts? "))
  salisbury = capacity(73,todays_length)
  print "Capacity on the TransWilts to Salisbury is",salisbury

Sample output:

  munchkin:rcp grahamellis$ python pyfunc
  Capacity to London is 728
  How many vehicles on the TransWilts? 2
  Capacity on the TransWilts to Salisbury is 204
  munchkin:rcp grahamellis$

The names that I've used in the function definition (seats_per_vehicle and vehicles) are generic names - in other words, a common name that might be applied to any set of values passed in when considering the functionallity that's being provided.

The names used in the calling code are more specific - and indeed they can be variables, constant values, or even expressions.

The values passed in are position dependent. The function requires two paramaters in this example, so the call must be made with two values. The first of these values is passed into the first named parameter, and the second value is passed into the second named parameter.

In most langauges (including Python, used above, and C and C++, below), variablenames within the named block of code are in a different namespace to variables in the main code. In other words, it doesn't matter what names are used within the function - they can't be seen in the calling code. They could even be the same names, but they're actually different memory location. Think of it like forenames and surnames. I talk about "John", but "John Smith" and "John Brown" are different people.

But there's very often much more than just two numbers to be passed into a function - you'll very often have a whole raft of values and the calling sequence would expand from one or two parameters to a very much higher number if something better wasn't done.

As a starting point for this demonstration, I've placed a C function definition and used in a sample program [here]. The function has two parameters - a width and a height:

  float getdoggie(float w, float h) {
    float rv;
    if (w > h) {
      rv = h/2.0;
      }
    else {
      rv = w/2.0;
      }
    return rv;
    }

and so it's called with two parameters:

  d = getdoggie(w,h);

Using a structure in C, we can gather all of the values we want to handle in our function into a group, and simply pass in the group (or, better, the address of the group) into the function. Sample code [here].

Structure definition:

  typedef struct {
    int width;
    int height;
    char *material; } table;

The function definition then has only a single parameter:

  float getdoggie(table current) {
    float rv;
    if (current.width > current.height) {
      rv = current.height/2.0; }
    else {
      rv = current.width/2.0; }
    return rv; }

and it's called with a single parameter:

  d = getdoggie(mytable);

With a structure, it's still possible to call a function on the wrong type of structure, and each function name can only be used once. By adding the object oriented language facilities of C++, we can also associate named blocks of code with particular pieces of data. Not only does this tighten up on possible erroneous use, but it provides a separate namespace. And in turn that leads to us being able to share code within truely massive programs, but have that code well segmented for tested and maintainance purposes. The full example showing this from last week's C and C++ course is shown [here].

Here's the function definition:

  float Table::getdoggie() {
    float rv;
    rv = ((this->width > this->height) ?
      this->height : this-> width ) /2.0;
    return rv;
    }

and the call to it:

  float reach = dining.getdoggie();
  cout << "Dog Reach " << reach << endl;

The next series of public C and C++ courses runs in mid July ... if you're coming late to this article, though - don't worry. The course runs again in the autumn, and there will be three or four opportunities next year too [schedule]. If you've got a group of 4 or 5 (or more) delegates, it's probably more cost effective for us to run a private course for you; that way, the course can be tuned to the exact background and target application of your delegate group.