1. Describe the feature to YOUR stakeholders
2. Ask us for an estimate for adding the feature to the framework – if we think it is a good idea we will provide an estimate. If we do not think it is a good idea we will tell you why.
3. If your stakeholders accept this price and understand that the resulting work will be part of the framework and not their own (no exclusivity) you order the extension from us.
4. We make it a priority to create the feature and deliver it (fixed price according to estimate) as a new ECO release 
5. You, as the financer, get the first versions to verify that this is what you ordered and it matches your needs.

Voila a new feature has been added to the ECO framework for everyone to enjoy.

We call this strategy “User paid extensions”. Use it – it works.

The MonoAndroid trial is enough for our purposes here until we want to deploy to a real phone.
First spin of ECO on Android. First read this

Open up the sample that comes with ECO:

Open up the sln and ignore/ok this:

You will see this:

The ReadMe explains the missing projects but since you are a developer you will probably not read it.

Delete the missing projects. And add new references to MonoAndroidApplication1

Choose browse and find the assemblies you downloaded in the PhoneBuilds.zip

Define what to start:

Hit F5 – This windows shows:

Start emulator Image: Pick MonoAndroid_API_10

When the Emulator runs:

you choose it:

And you get this window, the Root directory of our PersistenceServer

This is a simple WPF UI that shows the information in our “database”

This is the Phone App

Press the first button :

The text of the button was updated. The code on the phone:

void button_Click(object sender, EventArgs e)
{
    EcoServiceHelper.GetPersistenceService(_ecospace).Refresh(true);
    Button button = FindViewById<Button>(Resource.Id.MyButton);
    IObjectList list = EcoServiceHelper.GetOclPsService(_ecospace).Execute("Class1.allinstances->select(a|a.Class2->notempty)");
    int noOfC1ThatHasC2s = list.Count;
    string extra="";
    if (list.Count > 0)
        extra = list[0].GetValue<Class1>().Attribute1;

    int noOfC1 = EcoServiceHelper.GetExtentService(_ecospace).AllInstances<Class1>().Count;

    button.Text = "db updated, Now C1 Total: " + noOfC1.ToString() + ", Total of C1 that has C2's " + noOfC1ThatHasC2s.ToString() + " " + extra;        

}

The code makes use of some ECO services.

The other buttons Code:

void button2_Click(object sender, EventArgs e)
{
    Button button2 = FindViewById<Button>(Resource.Id.MyButton2);

    Class1 c1 = new Class1(_ecospace);
    c1.Attribute1 = "Created on android by mono " + DateTime.Now.ToLongTimeString();
    button2.Text = "c1 created";

    _ecospace.UpdateDatabase();
}

We switch back to the WCF app – hit Refresh:

You can play around with the WPF app and the Phone app to ensure yourself that objects created in one client can be seen in the other client after a Refresh.

If things does not work consult the WCF trouble-shoot

That is all I am going to show you about the Android Phone right now. Disappointed? Don’t be – we did a lot – strongly typed model driven business objects on the phone with a WCF connection to the server – that persists everything – and lets you find what is on the server.

Client: Cool.

Sales: ECO also helps you to persist your object oriented information on the server – using the database of your liking.

Sales: ECO does this by providing WCF communication from the client to the persistence mapper placed on the server with a generic WCF interface.

Sales: ECO allows you to query the local domain cache of objects AND the persistent storage (the database) with LINQ and OCL (Object Constraint Language).

Client: Cool.

Client: How do I get that that app on to the phones?

This is how

Prerequisite

ECO can run on WindowsPhone 7.1 (Mango), you need windows phone SDK for 7.1  for this.

And with the use of Xamarin Mono for Android (trial download will suffice until you want to deploy) ECO also runs on Android phones.

The ECO-assemblies needed for WindowsPhone and Android are not part of the standard ECO-installation, they are in this zip PhoneBuilds.zip

You will also find this on the download page.

You also need a late release of ECO6 for VisualStudio 2010, also on the download page.

The model we use for the phone samples is this:

WindowsPhone

MonoAndroid

Open up the sample that comes with ECO:

Open up the sln and ignore/ok this:

You will see this:

The ReadMe explains the missing projects but since you are a developer you will probably not read it.

Delete the missing projects.

Choose browse and find the assemblies you downloaded in the PhoneBuilds.zip

Define what to start:

Hit F5 – three windows pop up (the phone emulator starts slowly):

This is a simple WPF UI that shows the information in our “database”

This is the Root directory of our PersistenceServer

This is the Phone App

Press the first of the X buttons in the bottom of the PhoneApp

The code on the phone:

private void ApplicationBarIconButton_Click(object sender, EventArgs e)
        {
            EcoServiceHelper.GetPersistenceService(_ecospace).Refresh(true);
            EcoServiceHelper.GetAsyncSupportService(_ecospace).PerformTaskAsync(new Action(() => {
                IObjectList list = EcoServiceHelper.GetOclPsService(_ecospace).Execute("Class1.allinstances->select(a|a.Class2->notempty)");
                int noOfC1ThatHasC2s = list.Count;
                string extra = "";
                if (list.Count > 0)
                    extra = list[0].GetValue<Class1>().Attribute1;

                int noOfC1 = EcoServiceHelper.GetExtentService(_ecospace).AllInstances<Class1>().Count;

                EcoServiceHelper.GetAsyncSupportService(_ecospace).DispatchTaskToMainThread(new Action(() => {
                    // UI Stuff - everyone is happy to see that we do this in the main thread
                        ContentStack.Children.Add(new TextBlock() { Text = "db updated, Now C1 Total: " + noOfC1.ToString() + ",\r\n Total of C1 that has C2's " + noOfC1ThatHasC2s.ToString() + " " + extra });

                }));
            }));
        }

The code makes use of some ECO services.

The other button:

Code:

private void ApplicationBarIconButton_Click_1(object sender, EventArgs e)
{

    Class1 c1 = new Class1(_ecospace);
    c1.Attribute1 = "Created on WindowsPhone " + DateTime.Now.ToLongTimeString();
    ContentStack.Children.Add(new TextBlock() { Text = "c1 created" });

    _ecospace.UpdateDatabase();

}

We switch back to the WCF app – hit Refresh:

You can play around with the WPF app and the Phone app to ensure yourself that objects created in one client can be seen in the other client after a Refresh.

If things does not work consult the WCF trouble-shoot

That is all I am going to show you about the WindowsPhone right now. Disappointed? Don’t be – we did a lot – strongly typed model driven business objects on the phone with a WCF connection to the server – that persists everything – and lets you find what is on the server.

Is your server running under IIS or DevServer?

Check PersistenceServer project properties:

Is your Client(s) pointing to this?

Search your project for persistenceMapperClient

this.persistenceMapperClient1.Uri = "http://localhost:52150/EcoProjectWindowsPhone71PMPWCF.svc";

You may find multiple entries – check them all.

NOTE: If you are looking at a PersistenceMapperClient that runs on a PhoneEmulator you should not expect Localhost to work. After all Localhost would be the phone?! Well on the WindowsPhone emulator Localhost is NOT the phone – it is the your dev-pc so you can safely use localhost. But on the Android emulator Localhost will NOT work, instead use the ip: 10.0.2.2 (so replace localhost with 10.0.2.2 )

The other half of the URL comes from your persistenceServer projects definition of the WCF Service:

Test if it runs now… If not:

Do you have a ClientAccessPolicy.xml file on your webserver root ? Note, “ROOT” not “Directory” – on the devserver this is the same but in IIS I really must stress THE ROOT of the webserver and NOT your Virtual directory.

Does it run? If not:

Turn on logging in WCF to see what the holdup is – read about this here pay extra attention to what is required if you have declared your own enum types.

The code-bug: Your code does not actually do the things you intended it to do, but it was typed correctly

The think-bug: Everything came out just as planned – but now that you see the result you find that you planned the wrong thing

The typing-bug is under control with use of strongly typed languages that use static checking with compilers. The strange thing is that not every coder understand the brilliance of this. And then there are many developers that understand the brilliance but are forced to use interpreting languages since it is the only, or at least most common, tool that works in the target environment – Javascript is one example.

The code-bugs are managed with unit-tests which in short is to explain what you expect your active code to do with some more test code.

The think-bug –  the only practical way to manage this kind of bug is to increase the development speed so that you can verify your thoughts quickly – learn, tweak and move on, over and over. This is where model driven development shines.

Clients and employers that pay for developers and coders should make sure that the only bug the developers are engaged in are think-bugs.

The Think-bug is the only kind of bug that gives value back to the domain issues we are set to solve – the other types of bugs is just a result of crappy tools and sloppiness from an immature field of engineering.

Model driven development as delivered with ECO raise the quality by being declarative in every aspect that involves your business objects – and thus nil out typing-bugs and code-bugs. It also raise the speed of development so that the think-bugs can be managed swiftly and elegantly.

In the 90’s

Earlier it was believed that the think-bugs could be avoided by a very detailed analyze phase – here we find the traditional water-fall methods like Rational-Unified-Process (RUP). But now very few software engineers back these ideas. The think-bugs often does not originate from a poor understanding of “now” but rather from an enlightenment of “how it should be” that grows slowly as a project progress. And this is why SCRUM and Agile strategies are so much better at software development – they have room for dealing with think-bugs.

Using model driven tools like ECO enables you to be truly Agile – not only are the tools at their best when we need to deal with the late changes that the think-bugs often are – but developers have a tendency to defend a solution they invested in (as all humans do) so having tools that minimize the investment done gives us developers that are open for change and can reason about the think-bugs without being defensive – this is key to solving think-bugs.

ACTUAL SCREEN DUMP FROM Modlr Inside VS2010

This is one of 50-something diagrams in a project that holds 150+ classes. Domain driven development and Model driven development IRL. Cool!

Picking the image apart piece by piece

Model

This is the model you produce. It is expressed in Unified Modeling Language (UML) and defines Class diagrams with inheritance, many to many associations with association classes, derived attributes using Object Constraint Language (OCL), fold pieces of the model into ViewModels with OCL, designed declarative user interfaces for a ViewModel (ViewModel View), define actions with ECO Action Language, catch information about processes, stakeholders, applications and terminology, define state machines, set up constraints and stuff like that.

Documtr

In Documtr you can catch rich text for every artifact in your model. Write up things that will help you remember, or background information for a solution. You can produce a full model report at any time combining your model with your documentation.

Prototypr

You can with Prototypr start your model. You can open up a ECO debugger to create objects and view AutoForms per class

WECPOF

With WECPOF you can take the model execution one step further – use the declarative ViewModels to render UI’s and your Action definitions to render menus – now you have a complete application to test on your users. 

Modlr

Modlr is the tool that helps you model your thoughts. Modlr is built with ECO for Visual Studio so there is a complete Model of the classes in Modlr in our code repository – and for those of us that appreciate meta –  cool.

ECO Design time

ECO Design time offers you design time support when binding data to your visual components. You can even get up an OCL editor that helps you to compile valid OCL expressions using the definitions from your current model.

And on the runtime side

ECO UI Help

In .net almost all the UI strategies has their own way of binding between data and UI component. In ECO we handle them all with a few specialized components.

Your compiled code

The model is actually folded down in the generated code as attributes on the generated artifacts. You can of course have loads of manually written code here as well. And you might have chosen to implement some derivations of attributes or associations in code. It is nice to know that we use incomplete classes to separate anything hand written from the generated stuff.

ECO Runtime

When your app is running and pulls in data from the database, have you ever struggled to keep track of what is loaded and not, what association needs to be fetched and if the other end of the association needs to be updated when you tie two objects together? This is what the ECO runtime does for you. It also offers other services like in memory transactions (boy can that clean up your code – no need checking ahead – just throw an exception and rollback), complete undo/redo stack, ability to linq or OCL to execute SQL queries to the database etc.

ECO PersistenceMapper

OR-Mapping is what we call it when taking a model expressed in UML and store it in a relational database. There are a few rules and a few options, like how to map inheritance – own table, parent or child table, but all in all it is a pretty straight forward process that you can use your standard personal dba for – or just push a button and get it right every time. In design time ECO also offers an automatic difference calculus that we call DB-Script evolution. This finds the changes you need to apply to your existing database after you have changed the model – just click and be done. OR-Mapping can also be heavily customized so that your app can run towards an existing database. You can even Reverse derive an existing database in designtime.

ECO Persistence Server

The ECO Persistence Server is a Tier Building block that shields your (possibly fat) clients from knowing about the database. Use this and your clients talk over a WCF channel that you fully can control with WCF configuration. Use this to get encryption or tunneling or as a way to get thru firewalls. The ECO Persistence Server also tracks what client updates what objects so that other clients can get notified about this with a low bandwith refresh call (Client synchronization).

Database scripts

See text under ECO PersistenceMapper

Note that on the Execute side most things are optional

I guess there are people around that refuse to travel by car since it is all “new and modern and not really needed”, and I know that there are plenty of developers that will not model their thoughts at all since it is all “new and modern and not really needed”. ECO for Visual Studio is not for those developers – ECO for Visual Studio is for developers that like new and modern.

#1

When using many to many associations like:

It will fail adding to this association in Silverlight.

Reason: This construct creates an implicit link class (FriendExpensiveStuff) and the implicit class is created with reflection things not available in Silverlight.

The workaround is to create an explicit link class like this:

Then it works in Silverlight.

And frankly you will probably have the need for the explicit link class anyway:

We have tried the WECPOF method on a couple of real life cases and it is easy to see the value it brings being able to catch the class model, the viewmodels with UI-hints, the state machines, the actions , the high level processes, the stakeholders and user stories and the textual documentation in one place – then just execute it and show it to the users. The feedback loop is much tighter than what I have ever experienced before – and this is really important – people do not have time to forget the topic – and everything is accelerated in an unprecedented way.

I have heard all kinds of dooms day prophets saying that “You can never show a normal person a class diagram” – sure you can! Just make sure you show other stuff as well – like a running prototype with good examples of their own data executing that very class model. I tell you: normal people get this, normal people think this is fun, normal people want more and even faster. How cool is that?

What was wrong with WECPOF

WECPOF took the standard windows metaphor and made  lot of movable windows available for showing information. Standard but not without usability problems. And at the same time WPF and Silverlight kind of moved away from the windows idea and tried to establish a more dashboard set up for presenting information. We also looked at a few good and inspiring examples using only modal windows where the user could not switch windows to search for information – but instead needed to use dead simple and consistent navigations like “enter” for going into detail and “escape” for moving back from detail. This was surprisingly powerful, liked and easily learned by users.

So we had the old-windows-strategy that WECPOF used, we have the dashboard thoughts of new UI’s like in Zune, we had a good real life case dealing with only modal windows in a “one thing at a time kind of way”.

We also needed something that will sit well in a browser, a tablet, a phone or what have you… So how does a web app really work? It almost always deal with one thing at a time. You can always go back, and then go forward, you can always get a new tab or even a new window. And the navigation is always very simple, hardly ever any right clicks. Navigation is grasped by anyone in just seconds. We want something like that for WECPOF.

How can we fix it

WECPOF2 borrows a lot from the alternatives described above. Let the screens stack up on each other, give the user a back and forward button to move around in the stack. Just as a ctrl-click in the browser brings up the target in a new tab – a ctrl-click in WECPOF2 creates a new tab. As WPF and Silverlight apps often have a function panel, or a function stack on the side so does WECPOF2 offer the actions available in a button stack on the right side.

Just as with WECPOF(1) WECPOF2 also lends itself to heavy styling.

Check out these screen shots:

Clicking the “Show project” from the right-side action stack…

… brings up the project view. The back button takes you back to the project group screen.

“Show task” will bring a the task screen – but I will hold the ctrl key while clicking…

Note that this screen shows up in its own tab, and the back button is not enabled since this is the only screen in this tab.

The above example is in the EcoSolutionShowcase – it is Silverlight 4 in a browser calling an IIS hosted persistence server over WCF and uses a SQLExpress database.

Even if this sample is very simple it still does things a generic way that lots and lots of apps built today will have a hard time to deliver. To name a few:

• A refresh function that ask the persistence server after LOB-data updated after fetch – and invalidates this so that individual objects are re-fetched
• An Undo-redo function for all LOB-data
• Efficient fetching of data based on the declarative descriptions of UI
• Model driven from top to toe – but plenty of room to create your c# stuff when needed.

So go figure – are you working in the most efficient way today? If not – why not?

ps. I was extremely pleased to see that WECPOF2 only is a new transformation layer – no changes were needed to the ViewModel, Action or Design architecture to get it in place – and WECPOF(1) is still available. This “proves” the strength of the concept – totally new presentation layer – exact same model. So anyone still worried about the Silverlight vs. html5 battle? Why not focus on YOUR business… Let the presentation follow your rules and ideas. ds.