Organic Programming

I never said this clearly until now: Quark is a new generation MVC framework for RIA. Yeap.. We are not competing with Rails like frameworks (and we don’t copy them) because our point of view is that RIA is the future for web based applications. Generating html code on servers is ugly,messy and stinks (uhhh )!
We are currently using Adobe’s Flash (because Flex is mature enough to build on top of it) but one day somebody should port our MVC on JavaScript or even better, should implement Quark Schema support directly in the browsers. If we succeed to promote our framework, I expect that in 5 years, Quark Schema language will be a web standard. If we fail,I think that somebody else will rediscover later what we are doing: there is just no other way!

Because in Quark applications, the domain knowledge is strictly separated from the framework, I can see coming a day when Quark like frameworks will get support for many languages (on the server side) and that will provide a solution to the dreams of MDA (without using UML of course).
UML is probably too abstract and not that friendly for traditional developers but the idea of building applications around of a domain model and to be able to easily port an application from .net to Java or to a new technology that will appear in 5 years, has real value.
With this approach, an investment that a company is doing in software will preserve his value many years.

We bet on promoting SensErp as a RAD tool to create working DESIGNS and PROTOTYPES for Enterprise Applications but when developers will taste its power, they will adopt Quark as their favorite programming framework!

Someone once said that successful people  put the same amount of effort on promoting their work as on work itself. We are not yet there but even so… these days we are changing the design for our start-up site and creating an early registration form on  sensErp’s  domain ( soon here : the best enterprise software platform: senserp.com!)

From those pages, I have a summary of what SensErp should mean :

“Elegance is not a dispensable luxury but a factor that decides between success and failure.” Edsger Dijkstra

We had a discussion today in a meeting and we had an strong insight: we don’t try to create/sell just another RAD framework but we are trying to sell: an environment that will enforce code discipline,an architecture that respects the experience of the industry (like MDA), best practices.

Really! We even decided to sacrifice from the programmer’s immediate convenience in order to deliver what we promise: reduced  maintenance costs for the final applications. That could annoy some users if we fail to communicate what we are really selling: DISCIPLINE in PROGRAMMING with  MVC,  good practices and environment that will inhibit programmers  to do clever tricks. Only at the end we should say that we sell  a simpler programming framework! Sure, we are also targeting Excel users (at least the most sophisticated ones and only for simple things like CRUDs,simple forms) but it just happens that doing a “visual editor for MVC” led us near possible alternatives to spreadsheets space of tools. It is risky,very risky for a business to educate his customers but we are trying our best to do it in a easy and rewarding way.

Yes, a good education is required to appreciate elegance but usually the most elegant solution is the one that is more simple and efficient (almost by definition of the elegance) and we are thriving to achieve just that!

By best practices we mean things like:

• loose object coupling [1]
• real MVC architecture (and as simple as possible)
• MDA
• don’t mix many technologies and APIs in the same place (or like mixing view with controller as in many pseudo MVC frameworks)
• Don’t re-invent the wheel [2] (we have reinvented it for you )
• Keep things as simple as possible but not simpler. [2]
• Learn from others mistakes, not your own. [2]
• Begin with an end in mind [2]
• If it’s not broken, don’t fix it. [2]
• others…[]

References:

[1] http://en.wikipedia.org/wiki/Loose_coupling
[2] http://social.msdn.microsoft.com/Forums/en/Vsexpressvb/thread/78f6a9ba-05eb-45b7-88d5-8bcfcf0643cc

Reading this post: http://ravimohan.blogspot.com/2006/07/but-martin-enterprise-software-is.html I’ve remembered that basically  I have the same beliefs. Doing a framework for enterprise software is not boring at all. Of course we all know that. Doing one to be successful is hard. I’m trying for the 3th time to create a real maintenance cost killer framework for Enterprise software and finally I’m happy with the results (Quark 2.0 is just awesome!!!)

It is almost common sense that a business idea should be a little boring in order to be a good businesses idea (and i’m a little afraid that the work for the framework was  not boring enough ).

Our business strategy:

• create a technology to reduce creation/maintenance costs for enterprise software (with real programmers in mind,even if we are oriented even towards beginners or more business oriented people). Yes, you have Spring,Rails that are OK for programmers with medium experience but we can do much more for “Excel programmers”  but also for programmers with various skills and interests!
• looking for a way to replace Excel :we are not creating a spreadsheet clone but we want a tool with a similar learning curve as Excel for nontechnical users
• flood the market with good quality software for SMBs (open source and commercial)

Given that, I don’t think Enterprise Software is boring for everybody (is boring only for some hackers) . There are enough people (actually many many people) that have business orientation and skills to use modern programming tools for the creation of new, beautiful and useful software for companies without even asking themselves if it is boring or not.

We are preparing a presentation for how-to-web startup contest  http://www.how-to-web.net/startup-challenge/

Wish us good luck!

A simple way to backup your server.

Backup mysql database:

mysqldump -u $mysqlUser -p$mysqlPassword database > dump.sql

or you can dump all databases to a single sql file

mysqldump -u $mysqlUser -p$mysqlPassword --all-databases > dump.sql

Backup postgresql database:

pg_dumpall -U user > dump.sql

but because this will execute on server there will be no user interaction so for this to work you need to create a .pgpass file in your home directory.
NOTE: make sure it has permission 600 or else it will be ignored.

cat > ~/.pgpass << ^D
host:port:*:user:password
^D
chmod 600 ~/.pgpass

You may need a remote server where to store your backup and you also want to connect without providing a password (a good tutorial can be found here).
NOTE:
a) make sure ~/.ssh exists on remote server and it has permissions 700
b) use “-p port” if ssh is not on the default port

ssh-keygen -t rsa
ssh-copy-id -i ~/.ssh/id_rsa.pub "-p port remoteUser@remoteHost"

An easy way to backup your files on a remote server is to use rsync

rsync -e "ssh -p remotePort" -avrp localPath remoteUser@remoteHost:remotePath

Create cron job

cat > /etc/cron.weekly/remote_backup << ^D
#!/bin/sh
######### Start backup script #########

######### End backup script ##########
^D
chmod 700 /etc/cron.weekly/remote_backup

Backup a folder to a tar archive

tar zcvf /archive/etc.tgz /etc/

or backup the entire server

tar -zcvpf /archive/full-backup-`date '+%d-%B-%Y'`.tar.gz \
    --directory / --exclude=archive --exclude=mnt --exclude=proc --exclude=var/spool/squid

Download complete backup script

Even if asynchronous programming can get tricky, it enables a beneficial declarative  coding style.  I will present a few use cases for which  benefits outweighs the risks (risks that could come from bad/stupid programmers mainly):

• Form validation.  Data validation is a natural part of the model (remember the fat model idea) and it is not part of view for sure. With triggers in quark, it is possible to easily set metadata about invalidity of fields/objects and the view  will just reflect changes in metadata.
• Loose coupling in MVC and support for View States (quark terminology). The idea is that a type of data (an object) should be  differently viewed by the user depending on internal values.  In quark, asynchronous triggers will watch member values, set  a ViewState metadata and the view is switching to a proper view. Imagine doing this in a pure procedural way… This solution offers  the best possible loose coupling in Quark’s MVC  (only one way loop communication between V-> C ->M->V in this order)  .
• Implementation of the business rules layer.  A way to  enforce specific business rules on the quark models is by using triggers that  will watch values and as result will create new objects,change values.

I was always passioned on how to make programming a easier task. A direction that looked promising to me when I was a student was about programming techniques based on asynchronous behaviors. Asynchronism allows a declarative style that can simplify(minimize) the code,at the expense of  some complexity in behavior.  In many cases that is the right thing to do (such asynchronous code could be expressing business rules (what) and not how you do low level variable management => usually a very good practice ) but you have to simulate it in pure synchronous programming languages.

Many years after school, when I discovered Action Script and his events model based on observer design pattern, I instantly liked it.  I know that many programmers have serious problem dealing with asynchronism in their code and for good reasons (and others are abusing it when simple function calls should be used ). The usual solution is to create synchronous layers  inside of an asynchronous environment and hope for the best

In Quark’s model description language, we have the idea of “trigger”  that is basically a function/observer that is automatically called when other objects get changed. While this is a very natural way for describing model’s behavior, a naive implementation of the triggers can become very tricky to understand. The cause looks to be the intuition of atomicity of changes in a function.

class example
{
 var a:int; //should never take a value greater then 10
 var b:int; //should be always 10 * a, or 0

 [trigger on a changes]
 function trigger1()
 {
   if(a >= 10)
   {
    b = 100;
    a = 10;
   }
   else
    {
     b = a * 10;
    }
 }

 [trigger on b changes]
 function trigger2()
 {
   if(b != a * 10)
   {
    b = 0;
   }
 }
}
 var e:example;
 e.a = 11;

Above code (in a hypothetical action script dialect) should result in e.b having value 100.
Still, a naive implementation of triggers, could lead b having value 0 if trigger2 get called immediate after b = 100. This is just a simple example that reveals how evil the asynchronism can get.
We will take the risk in Quark Framework to implement asynchronous programming but we try to prevent things like unintuitive/unexpected behaviors or infinite loops caused by asynchronous events.
The syntax of Quark Schema language is a mix of XML and Action Script (but not really like MXML) and we will publish/document later (before the first release of quark 2 planed in October).
The way of preserving atomicity intuition about functions/triggers, it is also a good way to minimize the number of function calls (especially calls on intermediate results).

We depend so much on our tools. Yesterday my Flash Builder(Eclipse based) stopped helping me with code assist functionalities (auto completion mainly) and I had a real problem producing something useful.  I spent a few hours finding a solution and I was very happy when I got it solved. (It was one more Eclipse madness, after reinstalling all,creating new workspaces,etc etc, I realized that i was importing Flex projects as existing Maven project not as existing Eclipse projects. Right: silly,silly silly bug in Maven plugin probably )

Are we as programmers becoming too dependent on our tools? The answer is “yes” . But there is no other choice. As humans, after the first stone we started using, we remained very dependent on our tools but that it is what makes us so successful.

Actually, here at Axiologic, we bet our money and time on creating a new generation of  RAD programming tools  (for programmers, consultants and middle management) so apparently we  should try to behave like drug dealers for geeks  (unrelated but a funny link http://archive.silliness.org/drugsvsgeeks.html)

We work hard to make our software your next drug! (we have even auto completion for writing code fast  ;) but we bet on intelligent tools and architecture to minimize the code that should be  written)