Fads, there are a lot of them. But I think there is substance to this one. It is the Startup’s and SME’s who are the ones to pay heed! View this particular fad with the same interest as the Internet Shop Front! Yes, it “levels the playing field” yet more.

Think about it, when you are financially at your most vulnerable, others will provision you with the infrastructure and know how that the huge corporates have, and pay through the nose for. But Bob is right, I don’t think this offers much to the big corporates. Much hassle for little return.

So don’t keep your heads in the clouds, start your reading here.

I suspect that computer people don’t always see, with regards projects, that a machine and its software are just useful tools. Sometimes the practitioners within a project can be much less than a “useless tool”, but I’ll curb my innuendo. If you like sci fi then you have a future view, but for now, software just comes as bundles, tools no more and no less.

Maybe a young IT practitioner is a little like a young petrolhead, or 1110000 1100101 1110100 1110010 1101111 1101100 1101000 1100101 1100001 1100100. Yes they plough heaps of their time (which is money) into their obsession, and in the case of the latter, occasionally plough their cars. We techies, well we get involved in train wrecks. Not sure why that is, but we do seem to have nerd like train watcher qualities! We “spot” language features and create equally useless lists.

But how do we get so carried away? How does our obsession cloud our ability to drive and deliver projects? Well did you check if my binary was correct? Excessive technical focus!

So, we can get carried away with the object of our desires (our latest language or platform or maybe device). But let’s think projects, the actual purpose for many of these odd obsessions. The project is the encapsulation of anything new that we do, or at least set out to achieve.

Let’s look at specifics, I’m thinking that

we don’t often see the project target too clearly

Must be all that astigmatism and close focus myopia. Or is it, as in so many areas of focused activity, that our minds just play tricks on us? We happily race towards a fictional target. Tilting at windmills?

Sometimes we trick ourselves by equating the fastest performing result with a meaningful project end goal. Yes not always the desired result. Obsessions, desires, I’m starting to feel strangely hot now, oh “Yeah, baby”.

Sometimes we show unreasonable reliance and belief in a silver bullet. Latest methodology anyone? The only way to steer a direct course? Oh please. Methodologies often rightly address the most common set of mistakes, but they can’t transmute lead into gold or does the sow’s ear to silk purse metaphor do it for you? Yes,

GOOD people over process

there was a reason for that one (lookup the Agile manifesto), but excuse the liberal addition of my extra defining word.

What else, seeing as this might be a veiled rant. Well just one more mistake we often don’t think about as techies – that a “working solution” might not actually be more important than the perceptions of the client! Hmmm, if only I didn’t keep solving my wife’s issues and just said, “Yes dear”.

Does that last issue sound too extreme to you? Well, clients not only pay our fees but present us with the outline of a project. We might fill in the gaps but they need to be HAPPY. They might then come back for more. Or not!

Maybe the biggest problem for many techies is the absence of soft skills. Maybe because acquiring the hard skills takes so damn long!?

Our industry has grown so rapidly that now we have fast track routes to becoming the leaders within our domain. Well not in all places, but I’m sure you have been to sites where the PM’s ruled the roost! Some without a background in software process maybe or with little love for or ability with technical practice!!!

Hard skills, once they set, tend to make an essential bedrock on which to lay and seat those higher level skills. Do I have to say “Duh!”.

Ok, having indicated a little dissatisfaction, I will make note of what I see (warped as it may be) and make mention of that which represents what I do like within this loose discussion on the game of

Project hit and miss

A little Yang if you will.

I do like communication. Not just the “round up the nervous juniors to see if they can be made to talk or possibly pee themselves”. Ah you enjoy this pointless abuse of a non agile group mimicking a Scrum?  Yes, the session might last the length of an abstracted and quite boring Union scrum, but hey in the real world they introduced league to rectify that! It’s all about “shared thinking and shared goals”, don’t just copy a format because the course said so!

I do like that Scrum and Lean ARE giving new project focus and managerial techniques to technical teams that used to stay glued to their screens. Until the software got into acceptance!

I like the lead who checks on how things are going – both project and otherwise, and who both suggests and listens.  And even understands!

I like the sharing of leadership. Take the reigns when this feature is your forte. People who buy in by sharing their enthusiasm and ability. Yes, you’ve been in such a team and liked it I’ll wager!

I like a warped sense of humour and a distorted view of the world. Turn what is requested, or DEMANDED, upside down and inside out. You will be surprised by how amenable others are to a good solution! Ok, you will also be surprised by the opposite, but we’re trying to Yang right now.

I like people who realise that their most powerful tool, in their technical arsenal, is their noggin! Computers are still a bit like cars. You can make them sexy on the outside, go fast stripes and flashing lights,  but they are still as primitive as a hairy arsed baboon or a troop of PHB’s (Pointy-Haired Boss, see Dilbert)

You can’t always change the world around you. And with a skewed view of the world, maybe that wouldn’t be a safe move either. But if I have a warped perspective, it is only because I refuse to fit into a poorly applied matrix, or a pigeon holed role, or into anything which isn’t a part of a solution to a client’s real problem.

Is it time for a little closure? How about a simple credo?

make sure your project team tilts at meaningful targets

make sure your team has the most appropriate solutions

make sure the team consists of the right sort of noggins needed to implement them

I’ll be starting a new religion in my next installment.

I also discovered that there is a bug with formatting floats. One gets “.” instead of “,” leaving one with no idea where the decimal point is! You may have noticed on my last sample screen. This left me with no choice but to manually repair with a little string manipulation.

However, one win was with fonts. That shot also made it obvious that not everyone can see small print, so a little fiddling got the app not only easier to see, but also directed the attention of the user to the result.

A fun aside. Now I must get around to updating the data for the equations. Bye for now.

Well the entry is a little out of date but it is obviously now there. So, for those also targeting the export market, maybe this is worth doing!

Why mobile? Well there is no point in getting your shiny notebook all dirty, whilst outside, when your phone can do all the work! It’s a lot lighter too. We called it Tradie because it’s the kind of thing an Aussie tradesman might want to know the answer too, but just doesn’t have the Mathematica skills to address . We even added a metric option (the default) but wanted to show the same calculation as the first post (most of our readers are probably in the Imperial U.S anyway).

Actually (little history here) we had developed a video surveillance mobile prototype as a front end to the Gizzy product. As we recently reported, Gizzy is no more and so our fancy mobile application, which negotiated the Gizzy protocols to acquire video server images, is thus also no more.

Nonetheless, though markets are sour and companies are going under, there is an optimists view of this (I think)! As we had previously posted on the value of by-products, our skills are also a by-product of our work (those of us in ICT anyway). Though revisiting mobile development after over 7 or 8 months was a little stressful, the core knowledge and skills acquired got us going in record time.

I am tempted to take an aside and comment on how hirers acquire staff based on what skills they can evidence (via testing) on any particular day! Such a short sighted view of what constitutes skill and staff value! Not so much looking for a useful skills base but a monkey to jump though hoops methinks. No, I wont make comment

These are lean times in the ICT world and I will note that an exceptionally talented (and skilled) ex-colleague was unsuccessful with landing a contract. Oh boy does that company not know what opportunity they missed! Didn’t think a more mature candidate could keep up with the technology I am told. Hmmmm.

We’ll keep you posted on more experiments, prototypes and products as we go along.

Well last week I wanted to make a phone backup, cranked up Nokia PC Suite and automagically NSU ran and, for the first time, gave me the option to upgrade! Well the new firmware made my WiFi access more stable so I am very pleased that I did. And no hiccups, like a dead phone!

I followed the advice to the letter, I made sure encryption / lock passwords were all off, that the battery was fully charged (actually NSU won’t let you proceed until it is – the power supply could fail after all) and that my data backup was ready to restore, which it did. Even some of the applications survived the upgrade, so getting the ones I still needed was no real hassle.

Our latest LEXECORP mobile application (yes, shameless plug to be addressed later) also has an info page which reports on phone stats (like that battery level) and Software Version (2.0633.65.01 03-10-07 RM-227 (c) Nokia) which saves me searching for the weird set of numbers to key that will tell me just that.

Fun when it is easy

Life, like software, should be simple. Being conservative with upgrades (lazy) also paid off – I really had to do nothing for a nice result (thank you Nokia).

Now I recall there being a 3.* version of the firmware for Euro phones! So does that update still not apply to us in the Asia Pacific area?

So what might I try to renegotiate in Groovy – the latest enhancement to Java / JVM programming and my preferred tool for Perl’ifing the JVM . Well, in general OOP or Object Orientated Programming, does not beautify formulas (and thinking of Java specifically, no operator overloading was a disaster), but Groovy does give the JVM something of what has been sorely missing.

Now before you get carried away, the Achilles heal of Groovy is speed. If I had to do something seriously numerically intensive, like FEA (Finite Element Analysis) on a supercomputer platform, then I might look elsewhere. But for a quick dip into calculating a projectile’s trajectory, I think we will be fine.

Well whilst I was doing my Masters (Comp Sci) some 20+ years ago, I landed a placement with the British Ministry of Defence. Not just any site,  but the Proof and Experimental establishment.

What did they do? Well they studied projectiles. And a noisy firing range they had too. There were some very bright mathematicians there whose job it was to simulate and later analyse projectile performance. Sadly you have me. However, due to my lower calibre within this department, you will at least have a chance of understanding the code

Ok, here we go. A quick play with Mathematica and then some coding in Groovy is the result I offer you here. So, don’t shy away from Groovy. I know Python is the in thing for Numerical experimentation these days, but why follow the herd.

// PROJECTILES
//
// formulas - Thank you Mathematica
//
// h = (v^2 sin^2(alpha))/(2 g)    // maximum height
// x = (v^2 sin(2 alpha))/g        // distance traveled
// T = (2 v sin(alpha))/g          // travel time

// v | initial speed
// alpha | release angle
// g | acceleration due to gravity (~~ 9.807 m/s^2)

class Cannon {
  def final g = 9.807F    // acceleration due to gravity (9.81 m/(s^2)
  def deg                 // angle projectile is launched (deg)
  def v                   // initial velocity of projectile (m/s)
  def y0                  // initial height of projectile (m)
  def d                   // total "horizontal" distance traveled by projectile (m)
  def h                   // max height achieved
  def T                   // travel time
                         // radians = deg*(Math.PI/180)
  def distance() {  
    // x = (v^2 sin(2 alpha))/g   
    d = (v**2 * Math.sin(2 * Math.toRadians(deg)))/g
  }

  def height() {
    // h = (v^2 sin^2(alpha))/(2 g)    
    h = (v**2 * (Math.sin(Math.toRadians(deg))**2)) / (2 * g)        
  }

  def time() {
    // T = (2 v sin(alpha))/g
    T = (2 * v * Math.sin(Math.toRadians(deg))) / g
  }

  @Override  
   public String toString() {  
   """Cannon angle($deg degrees) Launch Velocity($v m/s) Initial height($y0 metres)  
      Distance: ${String.format("%.1f", distance())} metres
      Height:${String.format("%.2f", height())} metres
      Time:${String.format("%.3f", time())} seconds"""  
   }  
} // Cannon

// go
println new Cannon(deg: -90.0F, v:45.0F, y0:1.0F) // into ground

println new Cannon(deg: 0.0F, v:45.0F, y0:1.0F) // level

                                                // at an angle
println new Cannon(deg: 25.0F, v:45.0F, y0:1.0F)
println new Cannon(deg: 30.0F, v:45.0F, y0:1.0F)
println new Cannon(deg: 35.0F, v:45.0F, y0:1.0F)
println new Cannon(deg: 40.0F, v:45.0F, y0:1.0F)
println new Cannon(deg: 45.0F, v:45.0F, y0:1.0F)

println new Cannon(deg: 90.0F, v:45.0F, y0:1.0F) // straight up

which gives some results which Mathematica confirms to be correct

Cannon angle(-90.0 degrees) Launch Velocity(45.0 m/s) Initial height(1.0 metres)
           Distance: -0.0 metres
           Height:103.24 metres
           Time:-9.177 seconds
Cannon angle(0.0 degrees) Launch Velocity(45.0 m/s) Initial height(1.0 metres)
           Distance: 0.0 metres
           Height:0.00 metres
           Time:0.000 seconds
Cannon angle(25.0 degrees) Launch Velocity(45.0 m/s) Initial height(1.0 metres)
           Distance: 158.2 metres
           Height:18.44 metres
           Time:3.878 seconds
Cannon angle(30.0 degrees) Launch Velocity(45.0 m/s) Initial height(1.0 metres)
           Distance: 178.8 metres
           Height:25.81 metres
           Time:4.589 seconds
Cannon angle(35.0 degrees) Launch Velocity(45.0 m/s) Initial height(1.0 metres)
           Distance: 194.0 metres
           Height:33.97 metres
           Time:5.264 seconds
Cannon angle(40.0 degrees) Launch Velocity(45.0 m/s) Initial height(1.0 metres)
           Distance: 203.3 metres
           Height:42.66 metres
           Time:5.899 seconds
Cannon angle(45.0 degrees) Launch Velocity(45.0 m/s) Initial height(1.0 metres)
           Distance: 206.5 metres
           Height:51.62 metres
           Time:6.489 seconds
Cannon angle(90.0 degrees) Launch Velocity(45.0 m/s) Initial height(1.0 metres)
           Distance: 0.0 metres
           Height:103.24 metres
           Time:9.177 seconds

I am not surprised that the “Super size me” nation has the biggest and the most. Yes, the US is well endowed. My two sad little cores make for adequate performance but I’m not trying to visualize anything these days.

Yes, the big guns, supercomputing and where is it all happening? To find out, take a look at Top 500 and try the countries page. We (Australia) are somewhere in the others section. I am always surprised that the UK is so high up.

Scanning the top sites (installations)  and seeing mostly the U.S. and Japan,  it was interesting to see that the site I was working at is currently 24 on the list (Weather forecasting at the Meteorological Office takes some serious grunt).

Now isn’t Scandinavia a peculiar place. Tiny populations and yet countries like Sweden compete (in so many ways) on a world stage. Cars, mobile phones,… I think we Australians should pay heed!

Well, using Bob’s improvements with a little touch up (for densities and angles of repose), here’s a way to find out just how hard it would be to shift the mound of building material dropped on the end of your drive! Or, at least you can say how heavy it is and get someone else to shift it .

enum Material {
  CEMENT(131.0F, 45.0F),
  DRYSAND(90.0F, 41.0F),
  WETSAND(118.0F, 26.0F),
  LOOSEGRAVEL(93.0F, 50.0F),
  PACKEDGRAVEL(100.0F, 45.0F),
  CLAY(120.0F, 43.0F)

  Material(D, theta) {
    this.D = D
    this.theta = theta
  }

  def D
  def theta
}

class ConicalPile {
  def m
  def h

  def getWeightPounds() {
    def cT = Math.cos(Math.toRadians(m.theta))
    (Math.PI * h ** 3 * m.D) / (3 * (cT ** 2))
  }

  def getWeightTons() {
    getWeightPounds() / 2000.0F
  }

  @Override
  public String toString() {
    """$m
  Weight(pounds): ${String.format("%.0f", getWeightPounds())}
  Weight(tons): ${String.format("%.3f", getWeightTons())}"""
  }
}

def testHt = 10.0F
println "At pile height of "+testHt+" foot"
for (Material m : Material.values())
  println new ConicalPile(m: m, h: testHt)

which when run gives us something that looks quite reasonable

At pile height of 10.0 foot
CEMENT
  Weight(pounds): 274366
  Weight(tons): 137.183
DRYSAND
  Weight(pounds): 165467
  Weight(tons): 82.734
WETSAND
  Weight(pounds): 152964
  Weight(tons): 76.482
LOOSEGRAVEL
  Weight(pounds): 235709
  Weight(tons): 117.855
PACKEDGRAVEL
  Weight(pounds): 209440
  Weight(tons): 104.720
CLAY
  Weight(pounds): 234939
  Weight(tons): 117.469

I’ve been using dynamic scripting for a long time, like Python, Perl, PHP and TCL. But I thought I’d do this little experiment with Groovy. I’ve written FORTRAN in the past for scientific and statistical studies, but the language itself is a dog. The value, the formulas look like the math when embedded in ones code.

Will Groovy look good? Here’s my code and I think the Math looks just fine. Quick, clear and no fuss, just what a useful experimental language should be. Here’s the code

// Compute the weight of a pile of build material
//
// NB pile is conical with a natural degree of repose (specific to material)
//
// The formula I use
//     W = pi h³D / 3 tan²(theta)

// or via Mathematica
//     W = 1/3 pi (h^3 D) tan^2(theta)

enum Material { CEMENT, DRYSAND, WETSAND, CLEANGRAVEL, SANDYGRAVEL }

class ConicalPile {
  def h         // height
  def D         // density of Material (pounds per cubic foot)
  def theta     // angle of repose in degrees - this is a known constant(range...)
  def float W   // calculated weight

  ConicalPile(material, height) {

    switch (material) {
      case material.CEMENT:
        D = 131 // equiv to 14.1 kg/m**3
        theta = 45
        break
     case material.DRYSAND: // dry or moist
        D = 90
        theta = 35
        break
     case material.WETSAND:
        D = 118
        theta = 25
        break
     case material.CLEANGRAVEL:
        D = 118
        theta = 37.5 // 35 to 40
        break
     case material.SANDYGRAVEL:
        D = 118
        theta = 27.5 // 25 to 30°
        break                
     default:
        println "UNKNOWN material "
        break
    }

    h = height        
    W = weight()
  }

  private float weight() {    
     // ERMMM the formula says tan, but I use cos
    def radians=theta*(Math.PI/180)
    def cT = Math.cos(radians)
    // println "Math.cos("+theta+") == " + Math.cos(radians) // 45deg correct at .707   

    // the recipe       
    W = (Math.PI * h**3 * D) / (3 * (cT**2))
  }

  float getWeightPounds () {
    return W
  }

  float getWeightTons () {
    return W / 2000
  }

  void display() {
    println "Weight = " + String.format("%.0f", getWeightPounds()) + " pounds"
    println "Weight = " + String.format("%.3f", getWeightTons()) + " tons"
    println ""
  }

}

try {

  def ht = 10; // 10 ft high pile of builders material

  new ConicalPile(Material.CEMENT, ht).display();
  new ConicalPile(Material.DRYSAND, ht).display();

  return 0

} catch (Exception ex) {
  print "ouch"
}

Well a 10 ft high pile of cement is

Weight = 274366 pounds
Weight = 137.183 tons

and if dry sand

Weight = 140457 pounds
Weight = 70.228 tons

or thereabouts

[Ed: see the follow up for a better Groovier version]