himalia.net | community blogs

Watching this Chris Anderson's interview, he explains the new development methodology they are using in the Connected Systems team.

He says they are going beyond Testing-Driven Development (and obviously Behavior-Driven Development), they are not thinking how to test the code they are writing, they are thinking how to write the book that explains the technology while they write it!!!

 

Really, I don't know if it is true, but it sounds good.

 

TDD and BDD are based on how your consumer will use your technology, and in this kind of team, their consumers usually read the book while they use the technology. I don't believe you can rigorously follow this methodology, but it could be an interesting principle to have in mind while creating new stuff. 

 

P.S: BTW, he also thinks that WPF is a "tipping point" for model-driven development. May be the start for model-driven user interfaces? Who knows..

Labels: Developers, DSL Tools, TDD, WPF

Some people believe Himalia and Acropolis may overlap in some zones. And they are right! Himalia and Acropolis overlap in the zones where Himalia doesn't want to be... Yes, some time ago we had to build our own service schema and now we were thinking about a composite strategy for large teams... but it isn't our real focus. We just want to have more time to show you how we can build semantic user interface in minutes... this is our mission!!! (BTW, we will need this services schema anyway for the other platforms: asp.net and .net 2.0. Keep in mind that Acropolis requires .net 3.0)

 

Now that the first Acropolis CTP is public, our composite strategy will be far easier: we should put just on top of Acropolis.

So, I spent a couple of hours trying my first approach... (there are other two methods we are discussing right now and will attack in the near future).

 

**** Disclaimer: This code doesn't work with the public version available from December. ****

 

1. Create a Part Library, and name it Himalia.Acropolis

2. Add a new Part (HimaliaPart) and a new PartView (HimaliaPartView)

3. Add a new connection point to the Himalia Part: RootElement

  <AcropolisComponent.ConnectionPoints>
          <ComponentProperty Name="RootElement" />
  </AcropolisComponent.ConnectionPoints>

4. Override the OnFactoryCreationComplete method on the HimaliaPart

        protected override void OnFactoryCreationComplete()
        {
            base.OnFactoryCreationComplete();

            // Creates the Himalia Session in the WPF Runtime
            WinFxUISession session = new WinFxUISession(this.Name);
            session.StandAlone = false;
            this.Title = session.Title;

            // Set the root element to the connection component property
            this.RootElement.Value = session.Start<FrameworkElement>();
        }

5. Override the OnPartAttachedmethod on the HimaliaPartView

        protected override void OnPartAttached()
        {
            base.OnPartAttached();

            // Add the root element to the control
            this.Children.Clear();
            this.Children.Add(this.Part.RootElement.Value as UIElement);
        }

6. Now, in your Acropolis application, you can use HimaliaPart's, like this

  <AcropolisApplication.ChildParts>
    <Him:HimaliaPart Name="C:\\PetShop.hui" />
    <Him:HimaliaPart Name="C:\\Invoices.hui" />
  </AcropolisApplication.ChildParts>

7. Replace the OnActivated method of the Application (it throws a null exception because the MainWindow is bad set, I don't know why)

        protected override void OnActivated(EventArgs e)
        {
            foreach (Window w in this.Windows)
            {
                if (w is Window1)
                {
                    base.MainWindow = w;
                    break;
                }
            }
            base.OnActivated(e);
        }

8. This is how it should looks like:

 

Conclusion

You can integrate Himalia and Acropolis points of view nicely. In one side, Acropolis allow you to better segment the desktop application in divisible parts. On the other side, Himalia allow you to better create each part, focusing in the most important things for your users. Remember, Himalia focuses on usability and is a modeling tool. Acropolis focuses on composability and extensibility and isn't a modeling tool.

 

But soon, you will see how these developer-side separated user interfaces could be user-side integrated again... just give us some time.

 

Labels: Acropolis, Himalia, WPF

What do you see when you see Microsoft Surface? I tried to imagine me using it, in my daily tasks and not trying to create new activities... and I really think this new technology can help "software developers teams". I will write down the first two scenarios that came to my mind when I first saw this futuristic table.

DISCLAIMER: I will need this technology in table-format but in "picture-format" too (to put in a wall).

#1. Discuss diagrams

I am a visual-man. I like to see diagrams and discuss about them. I prefer to "see" ideas. I see things clearer in models than in other ways. So, I would want to see diagrams in the surface to discuss it with the team. That includes: class diagrams, database diagrams, navigation models, user interface prototypes, etc.
With this new approach you can move the boxes around the table, zoom-in/out to focus in a particular part, change some thing while everyone is seeing it... but you can also make changes and it is reflected automatically in your software-modeling tool. You won't need to write the paper on the wall with a pencil and then change it again in the modeling tool, or re-printing it to keep it updated from time to time.

 

#2. Card lists

If you are using an agile process, you may be using Post-it! notes in a public wall. Despite the fact they are very useful behaving as Information Radiators, they have a very important problem: if you are also tracking your tasks (or user stories or whatever) in a management tool you will need to enter each task twice (as a PostIt! note, and as a new task in your tracking software). And you can't avoid it, at least you want to lose all your project information with the first strong wind.

 

 

But what about putting the tasks in your wall-surface? You could move your virtual notes in the wall by hand to the next iteration (and constrain the movement in the reverse way ;)). But the good thing is that you can share it with your PMO in the other part of the world. And also, you don't need to see all the day long the same thing, it can show semaphores, team productivity, etc.

 

In the meanwhile, we could show Mingle in a big TV. When will Mingle support touch?

 

---

A collateral effect is that we can save paper (and so, help to avoid the pulp mills ;))

 

Finally, if Microsoft want to achieve success with this new technology, they have to keep the developers of their side. Yes, you are right, I am asking Bill Gates to gift me this toy ;)

 

What do you think about it? Do you see it useful? Do you see any other use for software developers?

Labels: Developers, Table computing, UX, WPF

I want to share these two WPF 3D examples:

 

1. Chris Cavanagh's Physics on XBAP, with source code available. 

Useful if you want to learn...

 

2. The Asahiyama Zoo (Japan) has released an XBAP called "Mother Earth." It looks cool but I will need some more training with my Japanese to understand what it can do ;)

Labels: WPF

Telerik has announced their Cube demo...

 

I know that with WPF the designers can free their minds, but... came on! I don't want to push the faces of the cube with my mouse! This kind of crazy-graphic-designer-made controls are only giving more arguments to Jacob Nielsen against the 3D (see 2D is Better Than 3D and Top 10 Bloopers for two examples, or look for "3D" in UseIt.com if you want more).

 

 

Some time ago, last year, while searching for early WPF controls, I found this cube calendar (Selector3D) made by Ricciolo. I didn't want to be less, so, I developed a control for Himalia using this free cube control. Now, is time to show it.

 

The control works like a 3D tab, just this, when you press the links the content moves in a cube-like to show the next content, but it's SO COOL when you play with the back and forward buttons! I must confess that I spent like 20 minutes just going forward and backwards the first time I ran it ;)

 

Believe me, you can't stop of pressing Back and Forward. And that goes even worst, when you notice that got all this stuff with just one drag & drop in the designer, and that it's full reusable, and...

 

Just in case, the Navigation and Layout models for this example are the following:

 

The container control is the "red hollow rectangle" in the navigation model, and it means that all the elements within it will be presented using one only control. In this case, we selected the Cube control to do this task. Obviously, the control should know how to present that navigational path, but it is defined in its contract.

 

But don't be anxious, we will include this control in the next release...

Labels: Controls, Himalia, Usability, WPF

Microsoft (through Wilson Pais) invited me to talk in the first Architect Forum of the year in Santiago de Chile.

 

I also used this opportunity to visit a friend of mine who lives there, Hugo Cortés. I meet him for first time in March 2004 when he come to Montevideo -as a member of Un Techo Para Chile- and helped us to create Un Techo Para Uruguay, a non-governmental organization that help houseless people in my country. I'm outside the organization now (because you can't do everything at the same time), but I really feel as a member of it... technically, I'm one of the founders ;)

 

Back to the Architect Forum, Alejandro Pacheco made a discussion about the available technologies for the presentation layer. After that, Martín Cabrera introduced Domain-Specific Languages, and showed a mini-example. Then I presented Himalia and finally, Carlos Carminati and Luis Molfino presented their company and what are they doing.

 

In the picture, from left to right, you can see to Martín Cabrera (Microsoft), Carlos Carminati (d2B), Luis Molfino (d2B), Alejandro Pacheco (Microsoft) and me. 

 

My presentation was specially discussed with the people, so I think they enjoyed it ;) I already know that the Himalia proposal is disrupting, and it's great when people keep thinking about these ideas.

This photo was taken by Luis Molfino, as you can see he's an artist :)

 

I want to thank you to Martín Cabrera and all the Microsoft Chile team. Surely we will meet again in the near future...

Labels: DSL Tools, Himalia, Talk, Travel, WPF

Reading this Joost Willemsen post I found myself thinking once again about the same thing: what is a page?

 

He tell us that single-page user interfaces are better than multi-pages ones. But.. how to understand it? Is a (Win)Form a page in a Desktop application?  What if you design each task in a different form? Didn't it has the same problems?  At the same time, using frames, you can see n pages at the same time... so?

 

The problem, from my point of view, is that the user doesn't know about pages. Pages are a platform related artifact, just like php archives, or java classes. Pages live in the implementation world, and NOT in the user world. The hypermedia paradigm tell us that users "know" about the hyperspace (something like the internal representation the user makes of the user interface).  Using this terminology, a navigational element represents an hyperspace concept, like an Amazon "Book".

 

User interface designers need to make conclusions about how to show related concepts in the screen at the same moment, but not about how to code html.

 

The Back/Forward problem

One of the most interesting problems related with pages are the Back/Forward commands. The Browser's Back/Forward is a page-based implementation. It was expected, because Browsers are themselves page-based.

 

However, it causes a lot of problems for the user because "going back" is not the same than "go to the previous page" in most of the cases. Particularly, we had this problem in an intranet application where we loaded some charts using a web services from the client side. I am sure that most of the AJAX applications out there have the same problem today, because you need to interact with the Back/Forward by hand to avoid it. Now, the Avalon Navigation support will have the same problem again, because it was implemented XAML-file based. Of course, you can subscribe to the Journal.. but... will be everyone handling it in the right way?

 

So, I think it is time to forget pages and start talking about concepts, hyperspaces and navigation elements. There are the real patterns.

Labels: Browsers, Himalia, Hypermedia, Usability, WPF

We have all ready to release the first public version of Himalia this week.

 

It will include the designer for VS2005 (Himalia Guilder for Visual Studio 2005), the abstract Runtime environment, the WPF adapter for the runtime, and a standard control library for WPF too. Although we have no intentions of providing controls, we should make it while we have no alliances with third party control providers. We have also included a study case in this package: the Pet Shop application.

 

We think that this release will allow you to "guild" very quickly very interesting UIs.

 

Some work was also made in the website, there is a comparison chart with other technologies like CAB, UIPAB, RubyOnRails and DeKlarit. Now, you can fix an idea about what kind of problems are we trying to solve with Himalia.

Labels: Himalia, VSX, WPF