This article is a stub. More can be said on the subject of how Lablz enables developers to practice Agile Development .

Patterns. Lablz implements Naked Objects pattern which facilitates Agile Development.

Metamodeling. Lablz utilizes Java Meta and extends it by adding a simple Meta Object Protocol to Java via Lablz Meta Classes. Lablz Meta Classes are just normal Java Classes. Lablz implements Semantic Web ontologies, which are a form of metamodeling .

Requirements analysis . Lablz models bridge the divide between business analyst and IT as they are much easier to read by non-developers and create a common ground for discussions. Upcoming Web UI for Voc will make it even more simple. Web UI for Voc allows to use existing collaboration tools directly on Voc objects. Such Lablz tools facilitate requirements analysis.

Domain driven design. Facilitates Agile Development.

Code refactoring.  Lablz enables developers to do Agile Development by automatically adjusting Object to Relational Mapping as developer re-factors his Object Model. One upcoming project in this area is giving user the ability to change super class to abstract class without ant drop. This particular project has the DB optimization benefit. SQL table of the superclass becomes a bottleneck if some of the subclasses have a lot of resources. All subclasses pay the penalty of joining with the SQL table for the superclass. When developer adds abstract modifier to a superclass, like DailFulfillmentItem, 'ant loadforce' will run a utility that will remove huge SQL table of the superclass and move all the data to individual tables of the subclasses.  We plan more of such refactoring utilities in the future.

Collaboration and continuous integration as practiced at Lablz shop itself:

1. use of SVN
2. use of collaborations tools: CRM
3. Lablz runs daily a 100% automatic backup for EC2 AMI. This backup machine tests the Recovery procedure from a server snapshot, runs symbolic (.csv) backups and a set of quality assurance tests.

Naked Objects pattern is a very ambitious idea. It aims to redefine software development process. It aims to bridge the divide between the business person and the IT geeks. It aims to drastically reduce software complexity and standardize the components. It sounds like an industrial revolution in software. We all heard that promise too many times. But I guarantee you that by the end of this article not only you will be convinced that it was possible, you will have practical ways to verify that it was already done the right way.

Lablz as Naked Objects

Let's reiterate the Grand promise of Naked Objects : No User Interface code, No Database access code, no any other code aside from business rules. You define Objects specific to your field of interest and you are done. The claim is so outlandish that it sounds more like Sci Fi. Or more like Saleforce.com's controversial marketing device "No Software". But it is real. It took Lablz engineers many years to evolve the initial ideas and prove that they apply to a wide range of complex business applications. Lablz demonstrated first Naked Objects application in December 2000 at the International Paper Trading conference in Vienna, Austria (before Naked Object pattern was named and before anything was published on the subject).

It is great to see that we were not alone thinking the impossible. Kudos to Richard Pawson, all the guys at NakedObjects.org and all independent implementors of this grand vision. In this article I will show how Lablz understood the principles and how it innovated by turning Data into Web Applications, Mobile Web Applications and Cloud Services.

Wikipedia article on Naked Objects lists its three core principles. As shown below Lablz architecture implements those principles solving many common Web Dev problems.

1. All business logic should be encapsulated onto the domain objects .

POJO. In Lablz Domain Objects are defined as plain old Java Objects, often without any logic attached to them - just plain declarations, a markup one might say. This makes Domain Objects simple to write and review for people with no programming skills. A Business Logic is added on an as-needed basis. This logic is very domain-specific, has no UI code, no middleware code, no database-access code - only the targeted pin-pointed business rules.

In Lablz business logic can be attached to Object's field and activated at the time Object it modified/retrieved or it could be attached to the whole Object in a form of onChange(), afterChange() and onCreate(), afterCreate() handlers. Developers may be relieved to know that rules are written in plain JavaScript - no hokey custom-made rules language. For ease of creating rules Domain Objects are automatically represented as plain JavaScript objects.

Modeling. The method of creating Applications by starting with Domain Objects is called Model Driven Design or Model Driven Architecture. In those methods developer first creates a Model and later uses it as a set of interfaces to build the rest of the software. Thus code ends up more structured and sane. The key advantage of Naked Objects is that Model is all developers ever needs to create. The shift from coding to Modeling will appeal to many experts and hobbyists who have bottled up ideas and comain knowledge but no way to convert them into running Web and Mobile Apps. Learn the ropes today with Lablz Modeling 101 (TBD).

Object-to-relational-mapping (ORM). Lablz supports multiple Data Sources, most important of which is the Relational Database. Lablz developed a unique scheme mapping Domain Objects to Relational structures. As with other parts of Lablz the design goal was to free developer from any involvement in ORM allowing developer to focus singularly on describing the Application Domain. The challenge was to achieve high speed for sophisticated Web Apps allowing complex Object graphs. Contrast this approach with Google Big Table and Amazon SimpleDB which force developer to maintain Object graph in the Application layer. In accord with Naked Objects pattern Lablz architecture does not have the Application layer. The only application code that needs to be written by App developer is the business rules encapsulated onto domain objects.

Evolvability. The Achilles' heel of Object to Relational mapping schemes is their inability to evolve gracefully as Domain needs change. For Domain Model developer it is hard to take into account possible needs several years ahead of time. Lablz Naked Objects abstraction allows developer to save time by focusing on the Domain Model that works today and rest assured that when change is needed Lablz will automatically adjust the underlying relational structures and even in many cases automatically migrate the data. Lablz developer need not know any XML mapping files, SQL TABLE structures, or run any utilities to ALTER the database. In many cases Lablz allows developer to safely modify Object definitions on a live Lablz server without requiring server restart.

Security. Lablz security aims to eliminate the bulk of access control administration by riding on existing Object definitions, relationships between objects, delegation of access control between Objects, by using rules which are based on actual data in Objects, and not on the artificial Access Control Lists (ACL) external to the Domain Objects. App developer does not need to create any UI for Security management and can augment security policies by adding rules on Domain objects.

2. The user interface should be a direct representation of the domain objects .

CRUD. In all Lablz Apps user interacts directly with Objects. User creates, views, searches, edits and removes Objects, otherwise known as CRUD . Every Lablz Object has its own Web page representation. In addition every Lablz Object is also accessible in a uniform manner over the network as a Web Service. See more on this subject in the next chapter.

Generic and simple. Lablz User interface does not control users and does not force users into a specific set of actions. Users control Data and Application, not the other way around. Unlike Spring Web framework or JavaFaces Lablz does not define sequences of user actions. User can interact with the Data starting from any angle - from a single object, a list, by drilling down or zooming out. All Data operations are generic, for example once the user learned how to deal with Invoices, she can easily interact with Payments, Issues, Orders, Banking accounts or any other types of Objects.

Transactions. Lablz Transactions are based on a very simple concept - each HTTP request is one transaction, which naturally for the user corresponds to a submit action in UI. All objects created/modified in HTTP request are committed or rolled back at the end of HTTP request. Sophisticated transactional cache gathers and maintains Object data graph. Upon transaction completion Object data graph populates the shared cache to speedup future transactions. Lablz Naked Objects Transactions may be compared with Service Data Objects, but provide higher degree of automation. In most cases App developer does not need to think about transactions.

UI patterns. In the year 2000 Lablz implementation contained only simple patterns to view a single Object, create and edit an Object, view a list of Objects and filter Objects by a specific field. Over the years, as Lablz created a multitude of vertical and cross-industry applications - many additional UI patterns were added. Today Lablz Application are enriched with Auto-complete choosers, scheduled and Ad-hoc reporting, Image galleries and Calendars, Point Of Sale device I/O and File Management, Product Catalogs and Shopping carts - to name just a few. And of course, Lablz UI is 100% Ajax-based.

Deep Search. Lablz built Web Search into all existing and future Lablz Apps. Lablz automatically indexes all structured and unstructured data advancing Web Search in the following areas:

1. Domain-specific results. Lablz has deep knowledge of Domain types and relationships, hierarchies and subordination, groups and memberships, and uses this knowledge to increase results relevance. Lablz Search also brings results marked with tags, slots and areas specific to user's Domain (e.g. specific to Hospitality industry).
2. Search as Ad-hoc reports. Lablz Search allows user to drill down, slice and dice the search results the same way user does with any Lablz Ad-hoc reports.
3. Secure for the Enterprise. Lablz Search automatically filters results through the same access control rules that govern viewing of any data in Lablz. It allows Enterprise to provide one Search for all internal groups as well as external partners. Search is just an integral part of any Lablz App.

3. The user interface should be created 100% automatically from the definition of the domain objects.

MVC. Famous Model View Controller Pattern (MVC) works amazingly well with Lablz Naked Objects implementation. Lablz View and Controller are completely generic and a Model is defined as Domain Objects. This leads to enormous time savings for App developers. To highlight this consider that Lablz View and Controller are developed for and tested on all modern desktop Browsers (IE6+, FF3+, Chrome, Safari 3+, Opera 9) and on mobile like iPhone, Android-based phones (G1, Magic, etc.) and Palm Pre. App developer is also completely freed from the hurdle of creating a complex Ajax interface.

Extensibility. Lablz UI is 100% automatically generated from Object definitions and Objects themselves. Yet if desired, developers can override any aspect of UI since every part/module can be augmented or replaced.

1. MVC View plugins - Java Bean Property Editors. Lablz employs a [modified] Java Beans Properties Editor architecture for MVC View plugins (modification was required to adapt Property Editor API to Web architecture). Lablz created a library of about hundred different Properties Editors for many field types used in business applications, such as Dates and Durations, Money and Currency, Rich Text and Enumerations.
   
2. JSP templates. Lablz uses about two dozen generic .jsp templates. These templates are reusable since they are not specific to any Domain Object. JSP files are easily modified or replaced. Although it is rarely needed, developer can define JSP templates specific to a particular Domain Object.
   
3. JSP Tag Library. Lablz provides over a hundred different Tag Handlers that provide common operations for all Object types, like login/registration, searching, tagging, etc..
   
4. MVC Controller plugins. HTTP request in Lablz is processed through predefined set of phases and each phase can have a one or more Handlers. Handlers are implemented as standard Java Servlets.
5. Data Sources. Data can sit in RDBMS like MySQL, Oracle, etc. or Data can be in File system, Amazon S3, or dozens of other Data Sources. Lablz implemented plugin architecture that abstracts any Data Source as a DavServlet. DavServlet is an extension of a standard HTTP Servlet  and handles WebDAV operation for full Object CRUD access.
   

Mobile and Touch UI.   Touch screens have entered the mainstream. A couple of years ago Lablz UI needed to support touch screens only for Point of Sale applications, like Bar/Restaurant and Retail. Today, with introduction of iPhone Touch is the norm expected by the users. Lablz has redesigned its UI to support a variety of mobile devices with displays that do not need a stylus and rely on a finger touch and gestures. Touch UI can now be used on all Lablz Apps - old and new.

Menu, Widgets and Dashboards. 100% generated Lablz UI extends well beyond interaction with the Domain-specific Objects. Modern Applications require navigational UI constructs like menus and bookmarks, tagging and categorization, headers/footers and side panels. They require different data views like lists, grids, viewing history, zooming, widgets and dashboards. Lablz provides it all, and it is all done via point and click in the Browser. As you probably have already guessed - all the described operations are also built on Naked Objects pattern - as bookmarks, tabs, menus, widgets, dashboards, tags, etc. are Objects themselves.

No designer required. Lablz' vision is guided by simple maxims. Web is a Database. Data is Application. Application is a Web site. Last maxim highlights a major difficulty any App developer faces, since rare is the gifted one who digs both code and visual design. The approach Lablz takes is: fine design can be postponed, often forgone. Lablz takes the lesson from Blogs, which let aspirants express themselves instantly and apply fine arts later. Thus Lablz App Web site is assembled much like a page on Netvibes, My Yahoo or iGoogle - a dashboard full of widgets. Lablz homepage itself was assembled this way. And so can be a front page and other pages of any Lablz App. Added bonus: it is so simple that users can do it too - thus any Lablz App is is guaranteed to give user extra fun.

Lablz is more than Naked Objects

Lablz is a rapidly evolving software. In the articles to follow I will show you that Lablz vision goes beyond Naked objects to truly express the maxim Web is a Database . Among the topics we will cover are Database access protocols, Data Manipulation Language (DML), Data Definition Language (DDL). I promise it will be more fun than just dry Database concepts since we will add the drama of the rise and fall of Semantic Web and how Tim Berners Lee, a true visionary, got stuck in the details of the vision he created.

VentureBeat spotted an interesting trend - independent bloggers migrate to blog networks with higher traffic to get more ad dollars.

The other type of aggregation which we saw in the past was when new Media companies evolved from individual successful blogs, like Techcrunch which grew into group blogs by inviting guest bloggers and adding new permanent bloggers.

Why all of this is mostly bypassing Old Media is beyond me. A week ago I watched a State of Play movie with Russell Crowe recently that portraits a dying investigatory journalism in a failing Newspaper. Sad.

Legit browser requests were classified as robots (false positive) and thus some functions, like tracking views were disabled for requests from this IP. This happened because we had an aggressive early-robot-detection rule:

If some IP address was detected as robot at some point then any other request with the same User-Agent header is considered a robot too.

This rule allowed us to detect googlebot and other frequently visiting robots much quicker when they arrived from a new IP address. But it was too aggressive as some unscrupulous robots apparently used a legit Browser's User-Agent pretending to be a Firefox. So, we had to roll up the sleeves and tune up the rules:

1. Defined a regexp pattern for known robots. Only those User-Agent strings of those confirmed robots will be used for early robot detection.
   
2. Added a property to manually confirm a robot even if it does not patch the User-Agent pattern for known robots.
   
3. Added a timestamp when robot was last seen. This will allow us to lift the IP blocking curtain after a set time. Without this rule we will ban some IP addresses forever. We will also need to add request rate metering into the time delay formula.
   

I have been pushing through with the task of VNC via SSL, which I posted on before . I believe that for future Lablz developers this is a critical component. And it is not just the obvious crossing-the-firewall benefit of VNC over SSL. Our target audience are somewhat less technical people who have a locked up precious domain knowledge and our offer to them is to unlock and monetize that knowledge. It could be a stumbling stone for them to set up VNC over SSH to communicate to their Lablz server on EC2 machine. Before they fall in love with Lablz, and I know they will - we want things for them to be 1-2-3. And it does not hurt to provide the one-click VNC access to all others :-)

Why Adito

But more important reason I was spending time with Adito is because its VPN capabilities allow SMBs and Enterprises to integrate their local network with the Lablz Cloud. And since according to Gartner report businesses are about to begin mass deployment in the Cloud - VPN becomes a must-have! Some people say Gartner's 7-years-to mass-adoption Cloud prognosis is too conservative, but to me it means large scale action has already began. SSL VPNs have earned their ground in securing remote offices and are proven in the field. Full-featured VPN integrated with Lablz will be a huge help for developers selling their Apps to SMBs and Enterprises.

At this point I can announce that the major progress was made with VNC over Adito SSL VPN . It is indeed just a set of clicks now to open a VNC and it goes over SSL as Adito advertised. No firewall trouble is expected ever again! Developer will not need to think about SSH keys, choosing SSH client, setting up tunnel and port mapping (and not all firewalls even have SSH port open), no need to choose and configure VNC viewer - it is all click, click click. It may feel a bit slower than VNC over SSH, but we can live with that. Those App developers who have more knowledge can later on setup VNC over SSH. Others may limit the VNC colors to 8bit and feel an instant acceleration. For more speed down the road - Adito has support for a speedy NX as well - but I have not had a chance to set it up yet. Adito also has an RDP client - so those future Lablz developers who choose Windows EC2 will not be left out.

Along with the work on setting up Adito I have replaced our default VNC server (RealVNC) with TightVNC server. Boy, it was not easy! If you like to hear the story - drop me a note. But it is done and it is working. This instantly gives us a nudge in speed and a couple of features which I really was after:

• A separate view-only password (confirmed to work and configured already through Adito). This is a must for developers to demo their new Lablz-based Apps. Much like a webcast software - but free and built into Lablz in the Cloud. You can broadcast a Browser session, a PowerPoint (or OpenOffice alternative), a Lablz in Eclipse training demo. To be precise it is not for a large audience - we will need to setup a VNC reflector for that, but for small groups it will be a lot of fun.
  
• Application Window sharing. When you do a Browser-based interactive demo you, as a developer want your potential customer to click together with you. This gives customer a good feeling, otherwise they fall asleep fast. But you do not want them to have access to your whole desktop. This is what TightVNC server promises to deliver. We shall see.
  

Remaining tasks

1. Web forward. We need normal HTTPS traffic to reach Lablz server. Adito has several types of Web Forwards. We need to see what is the best way. I have configured Nginx reverse proxy to Lablz server and I know it can be done (it was not that easy, but hey - this is Lablz Cloud for you - we take the pain out of deployment at the Web scale). But with all Nginx's fantastic popularity and an impressive speed record it does not handle TCP wrapping, like stunnel and Adito do (It can do HTTP, POP3, SMTP - so there is hope in the future). So, I setup stunnel and it was decent and worked with VNC server, but it does not handle HTTPS reverse proxy job. So, there it was the initial reasoning for trying out Adito.
   We also need Web forwards from Adito to Apache - to establish SVN over HTTPS (we use SSH for that now) and for other Apache-based apps, like WebSVN, etc.
   
2. Avoid double authentication. Logged in Lablz users should not need to login again with Adito. The good news is that Adito does not expose VNC's own authentication. So, that is out of the way at least. It is possible to create a custom authentication module with Adito, but I have not investigated it yet. What is needed here is for Adito to use Lablz User Database for its userid/password authentication needs. Adito also promises hardware token authentication, NTLM, LDAP, Active Directory, PAM and many other Enterprise class authentication choices. Good, we do need help in this area. 
3. Separate access to read-only VNC from full VNC.  I have not found a way yet in Adito to let limit access to full VNC as opposed to read-only VNC. Logged in user now can see both and this completely negates the read-only VNC option. 
   
4. VNC Application Window sharing. 
   
5. One time password for demo users.  As this may also be accomplished by setting up a temporary login - it is not a high priority, just a convenience feature. 

Update on Apr 29, 2009

I have given up on Adito as a Proxy and am exploring other venues: HAProxy , DeleGate Gateway , L7-Filter and other DPI (Deep Packet Inspection methods) .

Other uses of VPN

In the future the developer community can experiment with other possibilities Adito VPN provides, such as XMPP (Jabber) over SSL. This would allow businesses secure internal firewall-friendly IM with cross-connections to major IM networks. Luckily there exits somewhere an SSL Explorer (precursor to Adito) extension for OpenFire called Converse. It also helps that Lablz already has initial integration with OpenFire XMPP server .

Our mission is to give Lablz App developers the means to build, sell and support their Apps.
We at Lablz will go out of our way to see this through.
VNC over SSL is just one piece in this puzzle, but an important one.

Google just demoed the offline Gmail 'concept' on iPhone, Android HTC Magic and Palm. For app to go offline it needs both its data and code to stay on the device. While HTML5 database accessible from JS was available for some time now, HTML5 Application Cache is only now getting tracktion. To be fair it was implemented by Firefox 3 , but not in WebKit until recently. iPhone update 2.1 added it but it only works if you add Web app to a home screen,  according to this WebKit developers mailing list . The situation changes changes now as both upcoming Android and Palm Pre will both have App Cache. So, it is time to incorporate App Cache into Lablz.