For some reason none of these blogs comes right out and says the obvious.  Software development methodologies are like religions:  everyone has one and they all hate everyone else’s for no reason except they aren’t their sworn religion.  In real life, this is dangerous, expensive and prone to the types of failures noted in the blogs.

I haven’t worked in industry for 35+ years like Mr. Nizker but after a few projects it became obvious to me when you can use agile methods and when waterfall is the most appropriate.  Let’s try and do what none of the other blogs tried to do and break it down.

“Roll-out”

A very common thing in large companies (this was found via the CIO Weblog right?) is to take a newly developed solution and push it all over the world to standardize a business process.  These systems are the perfect candidate for the waterfall method.  The users can look at a system and see the gaps and let the people in charge of creating their “copy” of the system know about the changes.  This allows the “developers” to take the requirements in advance and while creating this new “copy” of the system add the modifications required for the new location.  Once the system is ready it can be easily tested with prior business cases and be easily validated for the new location.   I guess this is the “deterministic” task talked about by CIO Magazine.

“I think I need…”

Everything else falls into this category.  The category where the person defining the system has only half of a clue about what they need or want.  I do like the way Mr. Nizker classifies these problems, “[there is a] volatile reality, which changes on them every day [and] the systems we develop influence [that] reality.”  It’s sort of the Heisenberg uncertainly principal of IT systems.  Until we start to peel back the layers the people trying to define the system don’t know the extent of their own delusion.  You should think of it like therapy we must slowly work to the actual root of the problem.  You can only do this in an iterative manner until the user has seen the solution they have no clue what their problem even is.

It is all about using the right tool for the job and being able to tell the different before you start.  Just as using the iterative method is overkill for a roll-out style project, the waterfall spells total doom for the iterative project.  I rarely have a hard time deciding which tool to use.

The whole community collected around 2.5 million points last year.

If we reach the same amount of points next year, we will have 100K Euro. (If we don’t, we will walk in shame.)

If we reach 3.0 million points, SAP will donate 150K Euro.

Now if we even reach 3.5 million points, the amount will rise to the maximum of 200K Euro.

From the World Food Programme’s web site:

It costs just 10 US cents a day to give a child a cup of porridge at school. An additional nine US cents a day provides a child with a nutritional package, including basic health and sanitation support.

1 Pt * ( # of Euros / # of Points ) *  ( 1 USD / .67 EUR ) * ( child / .1 USD ) = Conversion

Roughly translated back to points that means for every point you earn on SDN you will feed between .6 and .85 children for one day.  With the average blog post getting around 50 points, one blog can feed 30-40 children that day.

“One person can make a difference and every person should try.” John Fitzgerald Kennedy

Let’s start off with one of the simpler examples just to get the hang of it.  Use SAPLink and install this function group and generate a web service from the one function in it.  Now, lets write some Flex code to call this.

Import Statements

A few people have asked me to add the import statements to this.  For reference if you go to the object that has the error, move your cursor to the end of the word hold control and press space the import will be added for you automatically, welcome to the wonderful world of a good IDE.  But the following in a <mx:Script> block between the <mx:Application> tags.

import mx.rpc.AbstractOperation;
import mx.rpc.events.FaultEvent;
import mx.rpc.events.ResultEvent;
import mx.rpc.soap.LoadEvent;
import mx.rpc.soap.WebService;

Simplest Example

Step 1 – Get your WSDL

1 private function callWebService():void{
2     fooService = new WebService();
3     fooService.wsdl = "http://localhost/sap/bc/srt/rfc/sap/Z_TEST_CHANGING_PARAM?sap-client=300&wsdl=1.1";
4     fooService.addEventListener(LoadEvent.LOAD, loadListener);
5     fooService.addEventListener(ResultEvent.RESULT, resultTrigger);
6     fooService.addEventListener(FaultEvent.FAULT,fault);
7     fooService.loadWSDL();
8 }

Line by Line:

1. Declare a function that will start the whole process
2. Create a WebService object, this should be global or at least visible to the other methods ( you’ll need it later )
3. Point the WS to the location of the WSDL
4. Add an EventListener for when the Loading of the WSDL is complete
5. Add an EventListener for the results coming back from the call
6. Add an EventListener for any errors that occur
7. Tell the WS to load the WSDL

Step 2 – Set Some Parameters

1 private function loadListener(event:LoadEvent):void{
2     var op:AbstractOperation = fooService.getOperation("Z_DOUBLE_ROWS");
3     var input:Object = new Object();
4     input.TEST = new Array();
5     input.TEST.push("foo");
6     input.TEST.push("bar");
7     op.arguments = input;
8     op.send();
9 }

Line by Line:

1. Declare a function who handles the event you subscribed to in the Step 1 line 4.
2. Get the Operation from the WSDL file.  This is one of those “standard” ways of doing things.  If you look at your WSDL file you will see that it could have more then one operation in it, this gets the particular operation you want to call.
3. Create a dynamic object that will hold the inbound parameters to your WS.  In this case the parameter TEST is a table of strings.
4. Here we create what Flex builder thinks is how to hold  a table, an Array.
5. Then we push each “row” of the table into the array again, in this case it’s just one string at a time.
6. See Line 5
7. We then map the input object to the arguments of the WS.
8. Send our request including all the input data to the server

Step 3 – Look at the Output

1 private function resultTrigger(event:ResultEvent):void{
2     var item:String;
3     for each(item in event.result){
4         trace(item);
5     }
6 }

Line by Line

1. Define a function to handle the event from section 1 line 5
2. Declare on object to hold each result
3. Loop at each item in the result list, which happen to be strings.
4. Print them out to the debug console

I will talk about more advanced parsing of the result set later on.

Inbound Table Parameter

First, get your WSDL, in this case I will be using the FM BAPI_FLIGHT_GETLIST from the SFLIGHTS example we are all so fond of.  You should run this FM a few times to make sure you have data on the ABAP side, I will be passing in a date range to this FM so, you might want to find two dates that return some data for you. ( I named my WebService “Z_GET_FLIGHT_LIST” )

Step 1 – Get Your WSDL

This is the same exact thing you did before, just with a different WSDL.

Step 2 – Set some Parameters

There is a strange behavior with ABAP WebServices where if you have a table that is both Input and Output you must pass it as part request to get it filled.  You’ll see in a second:

1 private function loadListener(event:LoadEvent):void{
2     var op:AbstractOperation = fooService.getOperation("BAPI_FLIGHT_GETLIST");
3     var input:Object = new Object();
4     input.FLIGHT_LIST = new Array();
5     input.RETURN = new Array();
6     op.arguments = input;
7     op.send();
8 }

Line by Line

1. Define a function that handles the event
2. Get the right operation
3. Dynamic input object
4. You have to pass blank parameters to the WS so that the Web Application Server will fill them
5. See line 4
6. Same as last time
7. Same here

Set Table Parameters

1     var dateRangeRow:Object = new Object();
2     input.DATE_RANGE = new Array();
3     dateRangeRow.SIGN = "I";
4     dateRangeRow.OPTION = "EQ";
5     dateRangeRow.LOW = "2002-12-20";
6     dateRangeRow.HIGH = "";
7     input.DATE_RANGE.push(dateRangeRow);

Line by Line ( add this between lines 5 and 6 from the prior example )

1. Create a new dynamic object that holds a Row of the DATE_RANGE table
2. Create an array called DATE_RANGE which will map to the DATE_RANGE input parameter
3. Set each field dynamically
4. More fields
5. More fields
6. More fields ( don’t need to pass this one because it’s blank )
7. Push this row into the array

Step 3 – Look at the Output

1 private function resultTrigger(event:ResultEvent):void{
2     var row:Object;
3     for each (row in event.result.FLIGHT_LIST){
4         trace(row.AIRLINE + " " + row.CITYFROM);
5     }
6 }

Line by Line

1. Function, again.
2. Use a place holder dynamic object
3. Loop at the table called FLIGHT_LIST ( looks like ABAP doesn’t it? )
4. Print to the console the fields you want ( looks like ABAP doesn’t it? )

Disclaimer: There are a number of ways to call WebServices in Flex, I believe this is the most complete and “standard” way to call them, if not someone please point me to Adobe docs that show the most correct way.

The new Synthesizer will have a few required tenets, listed in order of importance, underneath are a many “optional” components.  It’s okay if you don’t exhibit these characteristics — you might still be able to get a job flipping burgers:

Code

Sorry, namby-pamby non-coder types need not apply.  A real understanding of programming concepts is required.  However, I’ve found that Synthesizers are generally not language Nazis.  They are more opportunistic in their choice of language, they know a lot about probably one language but, also know when it’s not a good fit for what they are doing.  For instance, why would write a screen saver in ABAP?

Community

This is the area that allows Synthesizers to move faster then anyone else.  They know what is going on, they’re “plugged in.”  They know who is doing good work and they know how to stick those disparate parts together in order to get something better.  Doug Mccune ( my model synthesizer ) has put it best in a post about TileUI:

…how badass [the] open source community libraries for Flex are. I was able to grab these open source libraries and within a few days have something pretty sweet to show for it. A big thanks to everyone behind the PaperVision project, and to Alec Cove for the APE engine. You guys make this stuff easy. [ The making of TileUI ]

What else is in this quote?  Attribution, “A big thanks to Alec Cove for the APE engine.”  Promoter, you can tell from Doug’s tone how much the open source community helped him write this application.  Collaboration, without giving back to these communities you end up looking like a strip miner taking all the best out and not returning anything back.  A example from a totally different world is Thomas Jung, SAP geek and ABAP coder #1.  Thomas has built a ton of innovative stuff in ABAP from Matrix Screen Savers to a full replacement for the delivered web rendering system, changing it from HTML to Flex, named Flob.  At TechEd this year he released Flob, built using my library AJS, which he mentioned he had a few fixes for functionality.  This back and forth consumption and production allow open source projects to grow organically as need.

Communication

This is an obvious one, but again has a similar ebb and flow characteristic.  The most effective Synthesizers have a blog or are really active in forums.  They produce not only code but content, documentation, opinions — they care about what’s out there and what they are putting out there.  They probably read RSS feeds from dozens(at least) of different sources from many different areas.

Broad Knowledge

Underlying all these is less a tenet and more an obvious prerequisite.  Synthesizers want to understand stuff, they want to know about many areas not just Coding.  They might read about other sciences or be super into music.  Samuel Agesilas Pastel is great example of someone with groundings in music and design who also happens to be a sick programmer.  His UML modeling tool, called Saffron UML, parses actionscript libraries and generates great looking UML diagrams.  Just read his blog of a bit and you will see the diverse view he takes to software development.  That diversity allows Synthesizers to keep an anything goes mentality that enables them to see connections where other people see chasms they will never cross.

The funny thing with this set is maybe if you replace the first tenet with “industry analysis” or “accounting” you might get some other folks that are producing new Synthesizers — but I’m just a programmer what do I know.

Thanks to Synthesizer, maverick for the images.

The license you are granted is a development license if you intend to resell or license any of your solutions you create you need to get a different license from SAP

So what this means is that if you develop something on the subscription program you cannot resell it.  The EULA is pretty clear in this regard:

If You wish to use an Add-On or Consuming Product Application created by You in a production environment, or to otherwise commercialize and/or distribute that Add-On or Consuming Product Application, You must first enter into a separate agreement with SAP.  Under this Agreement You are not entitled to: … license sell, offer to sell, transfer, rent, lease, distribute and/or otherwise make available the SAP Software and/or any Add-On to third parties. [source: EULA]

Thanks to Eddie for the link to the EULA.

Basically this means if you want to sell something you need a new license and probably any open source work would also meet with a cease and desist from the SAP legal team. 

To compare this to another player in the industry the EULA associated with the MSDN subscription appears to not make any distinctions like this.  Granted the pricing for the MSDN subscription is a bit higher, New $10,939, then $3,499 / year thereafter.  Compared to the SDN Subscription cost which is $2,300 / year.  I wonder how the MSDN numbers compare with the cost of the SAP license to resell your solutions.

I think the subscription is a great idea and a big step forward for SAP but, to become a “platform company” they need to make it easier(cheaper being part of this) to get started in the ISV market.

ODE2Paper

ODE2Paper is the main visualization and physics library I wrote that underpins the Majority Desk application.  It binds the Open Dynamics Engine (ODE for short), which is the underlying physics system to Papervision3d (PV3D for short), the 3d rendering system.  The foundation of this interaction is actually very simple: every time Flex fires an ENTER_FRAME event I issue a refresh command over a socket that is connected to the physics server.  The physics server is a python application that uses pyODE to wrap the ODE libraries.  The physics server “parses” the refresh command,

<refresh/>

iterates across all the objects in its world producing a new XML document with the position and transformation matrices of all the existing objects and sends that XML back to Flex. 

<world>
    <o1 x="0.0" y ="0.0" z="0.0" r0="0.0" r1="0.0" r2="0.0" r3="0.0" r4="0.0" r5="0.0" r6="0.0" r7="0.0" r8="0.0"/>
    <o2 x="10.0" y ="15.0" z="10.0" r0="0.0" r1="0.0" r2="0.0" r3="0.0" r4="0.0" r5="0.0" r6="0.0" r7="0.0" r8="0.0"/>
<collisions/>
</world>

When this data transfer is complete on the Flex side, I move all the objects in the PV3d scene and then call the camera render.  Simple right?

A Wii bit of background

The Wiimote is a blue tooth transmitter, it reports its position and state to the blue tooth receiver on the client computer.  It determines its position by “looking” through the IR port on the front of the Wiimote at the poorly named sensor bar.  The sensor bar in reality has no sensors in it — it has two IR emitters that allow the Wiimote to triangulate its X and Y position in space.  The Wiimote also has an accelerometer on board that allows it to measure movement in the X, Y, Z planes (pitch, yaw, and roll).  This page has a mountain of technical detail about the Wiimote.

WiiFlash

The information from the Wiimote is sent to the WiiFlash server.  WiiFlash removes all the complexity out of using Wiimotes to control any Flash application.  The API is pretty complete and we found it to be fairly stable.  This is the section Eddie dealt with most so, I can’t talk too intelligently about it except to say that we use the WiiFlash AS3 API to access all the position and button state information from the Wiimote.  The API handles all the calls through a local connection that streams the information from the projects WiiFlash Server, which for now only runs on windows, sorry Mac faithful. 

This pretty much rounds out the subsystems that lie underneath the application.  This doesn’t really explain how the thing works so, I will walk you through how the Wiihands move around the screen to hopefully give you a better idea of what is going on.

Moving Wiihands

The most common thing we do in Majority Desk is move our Wiihands to interact with the world.  To allow interactions with the state of the physical world maintained by the physics server we have a set of commands in ODE2Paper.  The ones that matter for the Wiihands are createSphere, setObjPos, createJoint and breakJoint.  These methods serve as proxy for the real commands flying over to the physics server.  The rationale for this is again the main underlying concept that the physics server knows where the objects are and PV3d simply renders them.  So all the interactions are really taking place on the physics server.  The Wiihands are represented in the physics system as sphere because they are in reality just a cool texture wrapped on a sphere in PV3d.

So as a Wiimote moves we get its position and call a setObjPos method in ODE2Paper library which moves the object in the physics server.  Again the physics server leads and PV3d simply renders a view of the world.

Grabbing stuff

If you got the chance during Hacker Night or our Meet the Jammers session to mess with Majority Desk you may remember that if you hold the trigger and bump into something with your Wiihands you can grab it.  Letting go of the trigger will release the object and let it float around again.  This is achieved using the collisions XML node that I didn’t talk about earlier.  If you look back at the XML doc that the physics server creates to represent the world you will see an empty node there for collisions.  ODE2Paper notifies our Flex application that two bodies are about to collide via this XML node.  This allows us to detect that the Wiihand is touching something and then build a joint, using the ODE2Paper method createJoint.  A joint is a type of attachment between two bodies in ODE, we use simple static joints but a whole slew of different joints types are supported by ODE.  This is why the widget seems to follow a Wiihand around as it moves.  The great thing is this affect is achieved by just calling setObjPos on the Wiihand, which is the normal behavior described previously.   To release the object we simply call breakJoint and the physics server breaks the joint allow the attached object to move fluidly again.

If you want a run down of links and a good video that shows Majority Desk in action, check out Eddie’s blog post about it.

SAP is really starting to push the Composition Environment at this TechEd.  Recently I’ve started to think a lot about this topic given that it could radically change the way enterprise developers do their jobs.  This environment must also come with a new and necessary workflow akin to the Design – Developer workflow that MS and Adobe are both talking about.  Adobe has recently released Thermo which tries to address this gap with software.  Ryan Stewart gives a great rundown of the Thermo and the importance of this interaction:

It’s all possible because Thermo is a jewel of the designer-developer workflow. We can rely on Adobe’s incredible experience in creating design tools with our growing and powerful development framework, Flex. A good designer-developer workflow is so important to creating great RIAs. You only get great experiences when you combine the right brain of a designer with the left brain of the developer and let them collaborate.

Although, the design-developer paradigm is a good starting point it isn’t nearly complex enough ( not to say this interplay isn’t complicated but, come on if you put the wrong color somewhere your enterprise doesn’t stop running ).  The design-developer workflow relies on something else too — that both parties have at least a tacit understanding of what the other does.  There has been a lot of talk on SDN/BPX about this but, I am unconvinced that a common “language” is all we need. 

Life Guards

Development-QA-Production, the 3 tiered architecture that helps stabilize SAP development.  How will this be implemented in this workflow?  Where do the we do business process re-engineering?  Who tests these changes?  How can we communicate the shared responsibility?

A common language doesn’t solve this problem — it would seem more like IT would have to transition resources to be the life guards at the pool.  Changing workflows and/or “document flows” can radically affect  the running or compliance of the enterprise.  Who serves as the gate keeper for these things?

Treading Water

Right now the average IT department is trying to do more with much less.  They are trying hard to build new functionality for their businesses in a choreographed manner, using all manner of controls from code reviews to OO design patterns.  One big question is how does the business person even ask for this new functionality?  What if there isn’t something in their enterprise service repository or what if a field they want isn’t there?  Do they create some vast wiki system?  Do they open an OSS message ( although we would have to make the GUI a bit easier to deal with! )?  Ah, I know Solution Manager — open a message there.  Great. 

We use certain programming techniques to do more with less, “Why not write this section of the project as a set of subsystems and a facade so we can use it again if we want.”  How can we see these interconnections if IT is just trying to tread water supporting these new “business process reengineering” tasks.

Leaky

I guess my main problem is that I know enough about programming to know that even when we have nice abstractions they never work exactly as planned.  “All non-trivial abstractions, to some degree, are leaky.”

…you can’t drive as fast when it’s raining, even though your car has windshield wipers and headlights and a roof and a heater, all of which protect you from caring about the fact that it’s raining (they abstract away the weather), but lo, you have to worry about hydroplaning (or aquaplaning in England) and sometimes the rain is so strong you can’t see very far ahead so you go slower in the rain, because the weather can never be completely abstracted away, because of the law of leaky abstractions.

When someone goes to change a business process they are using abstractions to deal with the complexity of business.  They are using objects created by programmers to represent the world and when we try and put them together there will be instances where they leak.  The biggest problem with this is that the person doing the re-engineering isn’t going to know.  They are just going to try and move blocks around till it works right and this is dangerous.  Adding more steps or trying to circumvent the abstractions inherent leakiness is bad and will just produce poorly designed processes. 

Mark Spitz

Success in this is possible — we just have to realize that the only way to do this is get people on both sides who have a shred of understanding about what the other half does.  The optimum process has to have a collaborative model at it’s core where the person doing the re-engineering is leading the way.  IT would continue to support this function with technical knowledge and broad enterprise experience.  Here is an over simplified version:

See even I can do swim lanes!

 This is such a great representation of online communities everyone does this — everyone has multiple personas when they are online, at the same time a noob and expert.

“Get your Wiihands on!”

For more pictures of the Mindspace check out Marilyn’s flickr photo stream.

It seems that most people fall in the latter category.  I’ve already spoke to a number SDNers from all different industries who see how they can use this type of interface in a broad range of applications.  A airplane manufacturer navigating large engineering drawings to business people visualizing data sets in 3d to see patterns.  This was the reaction we were hoping to create in the community a true sense of innovation and possibility.  It’s also been a blast watching people mess around with the interface.

Here are some great photos from hacker night with Mark Finnern and Marilyn Pratt messing around with Majority Desk.

Big thanks to Coté at Redmonk for getting this video up so quickly!

For those of you at TechEd you can drop by the clubhouse at 5 to “get your Wiihands on” MajorityDesk.

Also we will be talking about the architecture and the OSS we used at this evening’s hacker night.