Morfik Watch Test

One of the most telling signs that Morfik is really achieving its goal of making the creation of web applications easy is how little you see the word "Ajax" employed anywhere were Morfik users are involved. I remember telling Fuad Ta'eed, then Business Development Director at Morfik, that "the best way to do Ajax is not to know what Ajax is...". This line has remained in my head since that day and it seems to have been well proven, in the mean time.

Morfik was conceived at a time when there was no such thing as Ajax. In fact, work in the very early stages of what would one day become Morfik AppsBuilder started even before all the technology pieces that would, eventually, be called Ajax where widely available. This way, work Morfik always gravitated around making a very easy to use, RAD, web development tool. This lead to all the aspects of what is called Ajax becoming the underlying plumbing which makes the Morfik Framework work, but with which the developer needs seldom to have contact with.

One of the more interesting aspects of this is that Morfik applications make, probably, the most intensive use of Ajax of any out there, and users don't even think about it. In fact the reason why it is so easy to design pages in Morfik is because it uses Javascript code to exactly position and configure each element within the browser, at runtime. This means that your design is not constrained by what you can represent in regular HTML, because the Morfik Framework will employ runtime manipulation of the page's DOM (Document Object Model) to exactly configure everything to match your design.

Keeping all this in mind, I guess the anwser to the question of where is the Ajax is simple: It's everywhere.

I had an interesting chat with a fellow developer who was frustrated because he had to do a lot of programming work, in order to create a business application with Morfik. At first I was a bit puzzled, but as we continued to discuss this issue, I started to understand why he was so frustrated.

Morfik AppsBuilder 2.0 has a very slick look. It allows you to do some amazing things, very quickly, with its built-in control effects, thus making it really easy for you to create an impressive looking website quite quickly. This has a side effect. People that start to work with Morfik AppsBuilder (be it FX or BX) start to believe that whatever they want to do, it will always be possible to do it visually and easily. Well, that is not really true.

The fact that AppsBuilder gives you a compiler and an IDE, and not just a framework makes it possible for you to implement pretty much anything with it, but not everything you might want or need is ready built for you. Many times, speacially in areas which are more directly related to your business, you will need to engage in some serious programing and not just screen/page design.

Sure, Morfik's visually oriented design environment and RAD qualities will help non-experienced programmers to create web applications. They will, also, allow experienced developers to create sloppy applications due to their ease of use. This is a temptation that should be resisted, at all costs. It is fine to try to do as much visually as possible, for prototyping, for example, where you are not sure if you are going to keep what you are designing and need to get the prototype out quickly,

It is essential, on starting a new and serious Morfik project, to consider good programming practices and design and plan for it from the start. As with all development tools, when building complex systems, good design and architecture is much more important then the tool itself.

Morfik is a RAD, high productivity tool, but that doesn't mean that you will not be putting in some quility programming time when building a new system. What it does mean, we all hope, is that the tool will be continuously evolving and offering new ways to help you design the best pages and create the best quality code, with the least effort.

If you are new to Morfik and just about to begin your first project, set your expectations to a realistic level. Remember, your application is only going to be as good as you make it.

Recently I was showing a friend how an application could be developed using Morfik AppsBuilder, when he was called away to look at some deployment issues with a ASP.NET application he developed. Since we were together I started to follow what he had to do to solve those issues and was amazed at how many different problems he was having.

It has been now over a week and he is still having issues with deployment. What really impressed me in this is that it is not problem that is directly related to the application he built. It is a complexity problem inherent to the Microsoft ASP.NET environment. Most of the issues he had were related to environment configuration and component dependency and versioning. He had oriented the support staff to move the application from test to production environment and the it was the differences in configuration between these two environments that caused all the issues.

Of course, a Morfik AppsBuilder application is also dependent on environment configuration, but it has far fewer dependencies than what you get with an application that has been built with Microsoft tools or even with Java. This simplicity makes Morfik-built applications ideal for scenarios where there is a small or no support staff. It also makes them a very good options for deploying to end-user desktop and notebook computers.

The same forum post that called my attention to guitaraholic.com also reminded me about how badly websites that are heavy on Ajax perform in regards to search engines. Morfik applications are probably as heavy as you can get on Ajax, considering that Morfik apps are composed of a lot of Javascript and a little HTML.

What this means is that Morfik built applications do not fare well when it comes to having their content crawled by search engines. In fact, this is the primary reason why this blog is implemented using a general blogging service, instead of running on a custom built Morfik application.

Another recent post on the Morfik forums, this one by Aram Mirkazemi, Morfik's founder and CEO, promises some improvements in the area of Search Engine Optimization for an upcoming release. Those of us interested in creating websites, instead of or in addition to web applications, can now cross our fingers and hope that this means the 2.1 release that was also mentioned. This would mean that we could be using Morfik in website building a lot sooner than I had expected.

Recently I had my attention called to a new website that is built with Morfik. The creator of the website posted a link on the Morfik forums and, with my curiosity working up, there I went browsing away to www.guitaraholic.com.

As most people using Morfik AppsBuilder (FX or BX) to build applications, looking over a publicly available website built with it is an interesting experience. The first thing I noticed was that the general color scheme is quite similar to that of the Morfik website. I guess this is not surprising as that is the most wildely know website to be built with Morfik AppsBuilder.

The concept is quite interesting. It seems to be a marketplace where you can enter information about guitars you own and read about the guitars that other people own. As you would expect, you can offer to buy or sell guitars, depending on the level of your membership account.

Guitaraholic offers three levels of membership, a free level in which you can only browse other's people's guitars and publish your own, and two paid levels which allow you to buy, and sell respectively. Not being a musician or guitar afficionado I have no idea of what the market for this is, but it certainly is interesting to visit, if you are considering the development of websites with Morfik.

I've recently began work on a new application using Morfik AppsBuilder 2.0. In sitting down to think about how it should work, I quickly came to the conclusion that I should actually break it down into more than one "Web Application" project.

The reason for this was that I wanted this application to publish a standard web services interface so that other systems could send it data updates directly and I wanted my own application to use the same web service entry points to do its data updates. This approach avoids redundant work in creating more than one way to update the data and helps make sure that all updates go through any validation you put in place.

This presented me with the issue of how to access the data for user display, as it seemed obvious that the actual database would reside with the "web services interface" module of the application as it was tasked with updating the data. The solution I came up with was to create an external Firebird data connector in the "user interface" module, that maps the tables from the "web services interface" module's database. This allows me to create forms and queries based on the other module's database and thus normally design the browsing interface for this Application.

The ideal solution for this scenario would have been to use the Web Services data connector and instead of an External Database connector. This would have let me concentrate all data access in the "web services interface" module and actually allowed me to have the "user interface" module build without any physical database knowledge or access. Unfortunately, though the publishing side of things for Web Service Data Sources seems to be working fine, the "client" side code seems to be broken in the Morfik FX 2.0.5.18.

The scenario which I am currently using, though not ideal as one module needs to have access to the other's database, seems to be working out quite well. I've always considered Morfik AppsBuilder a very convinient tool for quickly putting together a set of web services and my recent experiences seem to be only confirming this.

I use Morfik 2.0 just about everyday. It is a great tool, a great product. One thing I can't stand in the product, though, are those obnoxious sliding panels on the side and bottom of the main window.

Why should things keep moving in my screen when I haven't clicked on anything is totally beyond me. I use a decent computer to run Morfik AppsBuilder 2.0: a Core Duo with 2GB of RAM and a nice enough NVidia graphics adapter with dedicated memory and still those panels are annoying when you are just moving your mouse around and just accidentally happen to move over one of their tabs.

Worse thing is that I see no reason why the panels should not require me to click on them in order to come on screen. If I have to click on a tab to make a panel visible, it stands to reason that they will only appear when I want to see them, while if they just come up whenever the mouse moves over them, they can be triggered accidentally.

The funny thing is that almost everybody I know complains to me about these panels, and I sypathise entirely with them. I hope that in the upcoming 2.1 release Morfik either changes this annoying behavior or at least makes it optional.

What about you? Do you like the current behavior of sliding the panels into view or does it bother you too?

Morfik reports are a great idea! I have lost count of the number of times that some complained to me of how bad a receipt of invoice looked when printed from a browser.

Morfik reports by using Adobe's PDF (Portable Document Format) file format to represent reports allows clear viewing and printing of actual reports, without the default headers and footers added by all browsers. Add to this the fact that you can save, store and email your report to other people and you have got a sure winner for providing lightweight reporting for web applications.

Morfik reports are ideal for generating small printable documents such as invoices and receipts directly from your own web application, without needing to bring in the cost of a full fledged reporting solution, which can be pretty expensive, to the cost of your solution.

In version 2.0 of Morfik AppsBuilder a few bugs seem to have crept into the reporting engine, making more sophisticated reports come out with some issues. Hopefully, most of these issues will be fixed when 2.1 comes out, allowing Morfik reports to become the great tool they have the potential to be.

Some months ago I got an Asus EEE PC 1000 HD netbook.  I got it so that I could always have a notebook on hand for writing. I have been writing books for 13 years now but I am having more and more difficulty to concentrate on what I am writing as my 6 year old son does the possible and impossible to ensure that I can't get any work done. :-) 

I would like to wish a Merry Christmas to all the readers of this blog. I hope that this has been a good year for you and that 2009, despite all the gloomy predictions, will be an even better year.

I hope you have enjoyed reading this blog at least half as much as I have enjoyed writing it. In the coming months I am sure there will be plenty of stuff for me write about and consequently for you to read, as Morfik 2.0 has been getting more and more interest from people all over.

In the barely two months since the release of Morfik 2.0 I have been contacted by companies from several different sectors that want to get information on if it is possible to achieve this or that with Morfik or how to do it. Some of these companies have already hired staff and started new projects based on the Morfik 2.0 platform and I feel that this is but the start of a very interesting period for Morfik.

So, take a few days to relax and have a nice holiday season with your family and friends. Recharge your batteries and jump right into your 2009 projects.

Merry Christmas!

Morfik Basic is one of the language syntaxes which are supported by Morfik AppsBuilder 2.0. More specifically it is the language syntax used by Morfik BX which is one of the versions of AppsBuilder 2.0 released last month.

If you are a Basic user, this is good news for you. Morfik Basic was created to allow Basic developers to have easy access to the advanced Ajax application building capabilities of Morfik AppsBuilder. A lot of effort went into making sure that the extensions necessary so that the Basic language could reflect all the capabilities of the underlying Morfik semantics did not seem "foreign" to the Basic developer.

For example, in order to implement in-code documentation, Morfik relies on multi-line comments which are not available in traditional Basic. In adding this feature to Morfik Basic it was tapped from the C family of languages as Microsoft is currently the primary developer of a Basic language and it was reasoned that if they were to add such a feature to the language they would probably use their C# syntax.

For adding pointer support, on the other hand, it was decided that since C# has no such support, falling back to C++ or C would not be a good idea. In that respect it was decided to base the syntax in the ByRef and ByVal keywords that are used to specify how parameters are passed to Functions and Subs in Visual Basic. Reference parameters are, in essence, pointers and this seemed like a logical way of doing it, even if a bit verbose. The following is an example of a common declaration of a variable of the Integer type followed by a declaration of a variable that is a pointer to an Integer.

          Dim I As Integer
          Dim newX As Ref Integer

In order to actually the use the integer value that is referenced by this pointer you need to dereference the variable which is done using the syntax you can see in the following line:

          newY = DeRef newX +5

Though it seems a bit on the lengthy side, it seems to fit in with the Basic language practice and is actually pretty clear about what the code is doing. Considering that at application level there is very little pointer usage in Morfik and since there are no pointers in Basic it seemed better to write a few characters more every once in a while than to add a cryptic operator for the sake of saving some keystrokes.

In general I believe that Basic developers should feel right at home with the language, though like everybody else, they will still need to learn the Morfik Framework.

Having experimented with several of the built in themes in Morfik 2.0 I came to the conclusion that it should have a theme with more of a "clean" look. I really like the some of the themes that are bundled, including the one called "Default" which, not surprisingly, is the default one, but I really like to build web applications which have more of a clean look to them.

I prefer to work with white backgrounds, light and bright colors and add some visual effects (sparingly) for effect. I get this feeling that when you use too much of the visual effects at the same time, they loose a bit of their appeal, as they kind of "interfere" with each other.

Most of the themes that are bundled are just a bit too "rich" on visual effects to be to my liking and I really think that a "plainer", "cleaner" theme should be added to the built-in theme collection.

Of course, you can create your own theme with its own set of visual effects, colors, fonts, etc. I have done exactly this, twice already, but I'm not yet up to the same level of polish as the bundled themes display.

Morfik released today an update to AppsBuilder 2.0. The new build (2.0.5.18) fixes a number of bugs that were still present when the original AppsBuilder 2.0 was released, just last month.

The release of this new build just about one month after the introduction of the first 2.0 release shows that Morfik is working hard on the continuous development and stabilization of the product. Apart from fixing a sizeable number of bugs this build reintroduces the a FileUploader control that is non-flash based, as requested by many users.

From a full day of using build 2.0.5.18 I can say that it represents a clear improvement over the previously available build.

Morfik AppsBuilder 2.0 introduced a large number of visual effects that can be applied to controls and Form bands. Among these effects is the gradient effect, which is used frequently in a lot of web pages and applications.

Despite the fact that Morfik provides a large number of options for the gradient effect, it does restrict them somewhat when the control or band you are formatting is using a very dark or very light color. The form designer only offers you dark gradient options when the control is using a light color and light options went it is using a dark color. This can be a bit limiting when, for example, you want to have a gradient that goes from a light color to an even lighter one.

You can work around this limitation by temporarily altering the color of the control or band to a darker or lighter color (depending on the case) and then selecting the specific gradient option you want to use. When you return to the original color, the gradient selection is retained by the control or band.

It is probable that this limitation will removed by Morfik in a future release, as it is not a technical limitation and it makes little sense to take away formatting options that the product already supports. In the mean time, you can get around this small limitation by using this simple workaround.

Morfik AppsBuilder 2.0 introduced a very interesting feature for those of us that have an interest in writing elegant code. This feature is called Helper Methods and it pretty much allows you to add methods to any type in the Morfik language.

With Morfik Helper Methods you can add new functionality even to primitive types of the language such as integers, strings and booleans. The following code snippet is a short Helper Method written in Morfik Pascal.

function Boolean.ToString: string;
begin
   if Self then
       Result := 'True'
   else
       Result := 'False';
end;

The same methods could be written in Morfik Basic as shown in the following code snippet.

function Boolean.ToString as string
  if Me then
     Return "True"
  else
     Return "False"
  end if
end function

This topic is a bit too extensive to go into all the detail in a regular post, so I decided to make available for download a PDF version of longer article called Understanding and Using Helper Methods.

The information contained in this article is part of the material I have been putting together for the new book I am currently writing.

Morfik AppsBuilder 2.0 allows you to work with two kinds of projects: Browser and Web. Browser projects are strictly client side, running entirely inside the browser and Web projects include both browser and server side code.

If you created a Browser project and found out that you are really going to need some server side code, there is no need to despair. Though there is no way to convert a project from one type to the other, you can create a new project and copy your objects from the other.

Copying objects between objects can be achieved in the simplest possible way, just Copy in one and then Paste into the other. This works flawlessly for just about all types of objects and all in types of projects, except for a small problem when you try to copy a form from a Browser project and paste it into a Web project.

Since Browser project Forms do not have any server side code, the IDE creates the server side module and class declaration and your form has been moved across. There is a small glitch in AppsBuilder build 2.0.4.78 (the first release build of AppsBuilder 2.0) that causes the member declaration for the controls in the form to be omitted from the generated server side code. It is very easy to get around this small issue. All you need to do is copy the member declarations for the controls from the Browser side form class declaration and paste them in the appropriate place in the server side version of the corresponding class.

This tiny issue taken care of, you are all ready to go.

As I mentioned before, Morfik AppsBuilder 2.0 introduced several new design oriented features. Among these features are the ability to create fully transparent forms and to regulate the opacity of individual controls. By combining these two new features you can very easily create a watermark effect for your application or website.

The following picture shows a sample application I am updating to take advantage of Morfik 2.0 features. As you can see it uses stylized world map as its watermark.

To achieve this result I stated by creating placing an image control within a container and loading it with the picture chosen for the watermark.  This image had its opacity dialed down so that it would show through some of the white background, fading the image which would otherwise get in the way of the user actually reading the text.

Through all of the current decade, application implementations have continuously moved to a web-centric model. Most applications created are now “web-based” even when their sole purpose is to be usage inside a corporate environment. This choice mainly derives from the ease of use of web interfaces, from the familiarity that most users get from using the word wide web, and from the ease of deployment.

Web applications, however, though not difficult to create when very simple in nature become increasingly hard to code when their complexity grows. Most Web related technologies were developed as mechanisms for document definition and not really suited for the development of applications, making some aspects of their use cumbersome. This began to change some years ago with a set of technologies collectively known as Ajax, which allows for a much more sophisticated communication between the code running on the browser and the server. The use of these technologies, however, further complicates the development process requiring extensive specialized knowledge on several different standards (HTML, HTTP, XML, CSS, SOAP, WDSL, etc) from application developers.

Into this scenario came Morfik. Morfik AppsBuilder 1.x was an application development tool that allows developers to create sophisticated Ajax applications without needing to have any knowledge whatsoever of the underlying technologies. The Morfik AppsBuilder 1.x’s Integrated Development Environment (IDE) directly supported several dialects of commonly used programming languages making it easy for many seasoned application developers to have complex web based applications up and running in a very short time. Morfik also makes it possible for these developers to reuse their extensive experience and segments of existing code, instead of having to learn an entirely new set of skills.

Having established an initial position for AppsBuilder as an environment for experienced software developers to create sophisticated Web based applications Morfik moved on to create AppsBuilder 2.0. AppsBuilder moved into previously unexplored country by adding an extensive list of visual design oriented features, making it much easier and simple, as well as much faster, to create a visually compelling Web applications.

At the same time, apparently based on user feedback, Morfik decided to consolidate the number of language syntaxes they supported in Object Pascal (Morfik FX) and Basic (Morfik BX). Both of these languages have been in use in visually oriented development tools for the creation of desktop and client/server applications for well over a decade and thus have large user communities who seem to be very interested in the prospect of having the same kind tools they used to create Windows applications for creating Web applications.

Morfik AppsBuilder 2.0 goes way beyond what you could achieve in the Windows tools, while going out of its way to remain easy to use. I guess the best way to describe the new Morfik IDE is as a MASHUP of Access (for the database creation parts), Delphi (for the programming parts) and PowerPoint 2007 (for the visual design parts). This combination of features from such disparate applications actually yields an amazingly well integrated and easy to use design and development environment.

From my perspective Morfik AppsBuilder is an ideal tool for startup companies to quickly develop their prototypes and take their applications to production. It is also perfectly suited for independent software vendors with its high-performance natively compiled server code and its non-reproducible obfuscation for browser code which combine with a highly productive development environment and a reliable open source (and thus having no licensing costs) relational database server.

Of course, there are many other uses for Morfik AppsBuilder that range from creating plain websites (something which version 2.0 made possible) to fast prototyping applications (even if implemented in other tools due to pre-existing corporate standards).

Morfik has certainly raised the bar for how you design and build highly interactive web applications, with its next generation environment. At a time when even Microsoft haters seem to believe that all development tools need to look and behave like Visual Studio, Morfik takes a totally different direction tightly integrating visual design with application creation and making it all easy to use.

AppsBuilder 2.0 brings some much needed and very refreshing innovation to development tools.

Quickly going over the first items posted here, on MorfikWatch, I noticed that perhaps it was time to write a little about how Morfik AppsBuilder 2.0 came to be and how it has been positioned in the Market up to this point.

My next post will be a short review of this history and of my own personal perspective on the tool's appeal to certain groups of developers.

I believe that anyone who tries out Morfik AppsBuilder, specially release 2.0, will agree that the best way to create an Ajax based application is to use this incredible tool and its great visual designer.

As you don't really need to know anything about Ajax to create a great looking web based application with Morfik AppsBuilder...