Embedding flash into pdf files have many uses: enriching PDF’s with animation, playing movies, handling forms or creating games. However, there is a huge problem with some flash files embedded: pdf file size.

If one embed a (lets say) 200kb flash file into same-sized pdf file, you can get 4-6mb pdf file. This is way too much: it is like 10 times more than it should be there. And this is quite typical result for more complex flashes, like ones with animation or requesting something from remote servers.

The problem might be related to custom flash player used to play flash files from within PDF. The PDFs with Embedded flash work even if there is no Flash player preinstalled on PC. It might be that these flashes are pre-compiled in PDF. So, heavily animated multi-page flashes could reach sizes of 50-60m, which are not appealing to download.

However, there is an approach to reduce the size of the PDF, and it is not that hard. Adobe Acrobat pre-compiles the embedded into page flash only, and not ones that are loaded, no matter if they are embedded in PDF itself or stored on the web. The loader flash does not takes too much space, also it can be the same for many pages (if flashes are similar in size).

There are 2 drawblacks of this approach:

You cannot pass custom parameters for the loaded flashes, or at least we could not find a way. So each loaded flash has to be compiled separately even if the difference between them is small.

You will have to add screenshots/thumbnails of initial flash sequence to each loader insertion, as starting frame for loader is blank.

And thanks for Aidas for finding this solution.

I am responsible for hiring process both in my own company and in the company I am working with now. And the biggest headache is to pick a right staff for positions that requires lots of training. For example, programmers.

The problem with web programmers is that either they are young, solo workers, really bad or really expensive. However, there are guys that stand out from the general crowd which you have to find.

Typically, a programmer gets interested in programming and computers quite young. Many programmers know they destiny before they finish school. The best of them start coding something before university as well. In my opinion, university gives very little to improve basic programmer skills, but some knowledge might be useful in long shot. I have seen some good ones that have never studied computer science or programming at all.

The best way to determine how a programmer will perform is giving him a task that he never did before. For example, grabbing something from other page, creating something with exotic library or something along these lines. The reasoning beyond that is quite simple:

First, you can see if they are capable of finding solution. If a programmer gives up, he will not learn any new tricks on his own. Searching can give a lot of answers.

Second, you can see how you can communicate with that guy. If it takes time to explain problem, then you will have same issue in the future as well. One should pick a programmer one can work with, no matter how good other choices are.

Third reason is that you can see his code. Coding web does not provides excuses to use unreadable code, though many freelancer folks / solo workers code for speed rather than quality. I am not talking about comments, but about simple things like variable naming or clear code structure.

There are also couple good questions you should ask and listen. Personally, I do not like programmers that do not try new things like frameworks or cms’es that speed up coding. They have to be curious and willing to learn.

Additionally, one should listen when they are speaking about former jobs – what they liked, learned or disliked. This is good to determine personal motives and if you can make them happy in your team.

Lastly, I always ask about most interesting project: one that is most difficult or interesting.

The final consideration is not only if the person is right for the job, but if you can provide a job that is right for that guy.

I have made hiring mistakes in the past. I wish I could tell if I can work with a guy from first meeting. Though life would not be as interesting then.

This week I had a really interesting problem to tackle: one simple script of mine behaved not as expected. And it took me couple hours of analysis for a simple ~30 line script to find the cause.

The script on itself its quite simple one – we have 2 numbers and 2 dates, one of them is in the past, another is in the future. We need to calculate current value from current date and 4 other values. To complicate the problem, we have to randomize things a bit by adding something (always positive value compared to last one) up to the current value so we do not get a straight line from starting point to the finish. There are some other conditions that impact calculation.

Ending coordinates are constant during whole execution of the script. Starting coordinates would be constant if we had no randomization as well. So, we store starting coordinates in separate .php file that is loaded in main script. Then new values are calculated, checked if they are not out of bounds and written down as new starting values to the same config file.

Testing provided no problem with the script, however in work environment sometimes counter went back in time. And no one could find the issue. The added value was always positive. The configuration file was saved. There was single configuration file used and no other programs overwrote it. Everything seemed ok and script worked incorrectly sometimes.

The problem was server load and disk space. During high loads on server, script execution was not atomic as expected, and file writes were slow too. So when 2 scripts executed at the same time, include file might be empty. Thus script would recalculate next value without having the data about previous “randomness” and it would be smaller than it should be.

The moral is that I should have expected similar problems. It is easy to forget concurrent environment of the web when programming or analyzing simple scripts.

I have to distribute a mailing list of circa 150 000 email clients and wondered what alternatives I have to in-house system. This has lead to some research of various options for mailing customers.

First there are 3 types of software I might use: web-based services, server based newsletter/mass mailing applications and PC software.

web-based mass mailing services are quite expensive for bigger lists. For example, icontact.com offers plans costing $699.00 for 100 000 users per month. Aweber.com is about the same (at least for smaller plans). It would be a good choice for a smaller permanent list.

Also I can’t tell how well web-based services would perform under my constraints. I need Lithuanian encoding, handling weird email addresses of One.lt – popular Lithuanian social network with emails that uses its own email engine. And it has its own spams filter as well.

Another choice would be installable php scripts that would offer mass-mailing or newsletter handling. A clear choice would be phplists – a free php script for that. It looked very promising at first, however I met couple problems. First, it is not as user friendly as you would expect from distributed php software. I had to change lots of things in php scripts manually, even disabling test mode or changing encoding. That is not acceptable. Second, its import scripts suck. I have not managed to import mailing list properly even after I removed couple checks. Overall, its interface is lacking and I would not recommend this software for no-techie.

I have tested PC software as well, for example SendBlaster. It was quite promising except the way how it handles international encodings. I have received empty letter in my spam box.

So, the question remains open : should I try to make something working from phplists, search for its alternatives or use our in-house mailing system.

Typically, all popular wordpress themes come with html comments to mark endings of div block. This is required for theme developers as it is much easier to see where particular block ends.

However, I do not like leaving code like that in production site. Although some claim that HTML comments have no effect in SEO, it might have effect in keyword discovery process. Additionally, they might have effect for various security plugins, that filter and block content containing bad words.  Third, I think it is bad to leave debug information in production sites.

The biggest problem of these is that WordPress theme frameworks like Hybrid uses these as well. So you will have to clean up frameworks source each time you upgrade your framework. That is not the best approach.

However, You can implement this by creating couple filters in your childs (or custom) theme  functions.php file:

function custom_callback($buffer) {

$buffer=preg_replace('/<!--(.*)-->/Ui',' ',$buffer);

return $buffer;

}

This will clean the code from comments when user is not logged in (for search engines and visitors).

Last month I took over support of one project that inspired this post. It is a website with couple static pages, news and galleries that was created with Joomla. The problem was that site owners could not support it. They are not computer savvy and the internal structure of admin panel is way too complex for them to understand.

Funny enough, I would have gone to completely opposite direction with that site design. Based on site requirements, I would install WordPress and code additional functionality. WordPress handles many things better than Joomla:

• Image upload and resize to sane sizes
• Article/news organization
• Simpler admin interface

And a lot of clients do not need anything more – they do not want to resize media prior uploading, or searching for missing plugins to do that resize on upload time. Also, content and organization is tragic in Joomla, and it is really difficult to comprehend for person that does not work with such systems daily.

Now Joomla has its own uses and I would not create complex sites on wordpress. However, how often developers think about customer needs instead of their development speed and “Power” of the application? Many of us want to show off with powerful options, lots of customizability as we cannot brag about nice code inside to the customer. Often it is not what customer needs.

Thus it is important to write down requirements of project before putting everything on most powerful CMS you know. Think what user wants to see and make it easy for user to navigate through admin panel to do the tasks he needs.

Recently, I had simple but interesting problem on wordpress where I could not find ready automatic solution: thumbnail generation based on image ratio. I use wordpress as CMS for image-heavy site.

For example, I want that 3 sized images:

1. For landscape pictures I need 202×133 thumbnails
2. For square (or alike) images I need 156×142 thumbnails
3. For portrait images I need 120×162 thumbnails

The exact size of thumbnails matters, as I want to put these images in nice picture frames, with no spacing around. So obviously, I need a cropper that should work automatically.

WordPress itself does not provide that function. Thus I started looking for plugin as basis for such cropper. I have chosen scissors – a very nice wordpress plugin I can recommend for others. It allows user to control resizing and cropping images on upload, also it provides additional options for resizing/cropping images automatically.

However, how to make this plugin crop images depending on ratio automatically? Well, we need to hack into its source.

All modifications done are in scissors.php, scissors_resize_auto($metadata) function. We work with medium image size, as scissors does not work with thumbnails itself (we could implement this as well).

Step 1. Configuration.

We need to configure scissors to use adaptive image resize for medium sized images, or it will not pass through the function. Obviously, we can’t use inputs to define image size for all 3 cases without more serious coding, so we stop configuring there and hack into source.

Step 2. Determining image ratio.

Image ratio can be calculated at this: $ratio = $srcW/$srcH; , where $srcW is width and $srcH is height of original image. If $ratio is bigger than 1, image is landscape, in other case it is portrait. For this case we assume that ratio between 1 and 1.3 means square image, though we could use other steps.

if ($size=='medium') {
if ($ratio>1.3) {
$maxW=202;
$maxH=133;
} else if ($ratio>=1){
$maxW=156;
$maxH=142;
} else {
$maxW=120;
$maxH=162;
}
$dstH=$maxH;
$dstW=$maxW;
…..

So, we now have the image size to use and the image would be resized to exact size required. However, the image would be screwed when original image ratio would not match resized image ratio. We need to crop image as well as resize it.

Step 3. Croping the image to proper ratio.

Luckily, imagecopyresampled that is used to resize image can crop it during same operation as well. For this, we need to calculate area we need to crop in original image. First, let us initialize some variables:


$startx=0;
$starty=0;
$endy=$srcH;
$endx=$srcW;


Then,


if ($dstW/$dstH<$ratio) {
$endx=round($srcH*$dstW/$dstH);
$startx=round(($srcW-$endx)/2);
} else {
$endy=round($srcW*$dstH/$dstW);
$starty=round(($srcH-$endy)/2);
}

The only thing left is changing imagecopyresampled request to


imagecopyresampled($dst, $src, 0, 0, $startx, $starty, $dstW, $dstH, $endx, $endy)

Which crops required area from center of original image and resizes it.

That’s it. The end product is still in development and will be launched this week.

1. Your server and domain
   1. First thing I would check is the spammy IP list. Is your IP address blacklisted? It happens, especially on shared hosting. Good place to start searching is http://www.mxtoolbox.com/blacklists.aspx . I would use a dedicated IP if I plan to do mass mailing.
   2. Do your IP address resolves back and how? If it has IP address in reverse domain address, they think it is a DSL – assigned IP and not a hosting one, so it is assumed that this is SPAM. If IP resolves back to your domain, it is a good sign.
   3. SPF record is highly advisable. Not all incoming mail servers use SPF record; however it never hurts to have one.
2. Your email message headers. Forging headers is bad idea. Your headers should be informative and correct, including message ID. It is important how you write your email address there as well, you should always use real name with email address where possible. Same is applicable for recipient email address as well. Prove that you know them.
3. Avoid spam words or keep their density low. The message should have enough text; however it should not be too big. Also, avoid excessive capitalization and spacing.
4. You should include information why they are getting this message, also your contact information, as well unsubscribe information (if applicable). You do not have to write that your message is not spam – only spammers do that.
5. You should use well-formed html if you have to use it. No hidden text, tracking images or similar – they are usually blocked by anti-spam programs. Also you should include text version of email.
6. Avoid using spam – mailers. The anti-spam programs know about them and how to recognize most of them. This is quite sure way to be flagged as spam.
7. Monitor your returning email box. See what messages got undelivered and bounced back. See if it is your problem or the recipient problem.
8. Upon registration, ask your visitors to add your email to their address book and use same email for communication with them. Address book is the best way to pass spam filters.
9. Some mail servers do not like too many emails from single sender at any point. Try to space out the sending of your newsletters.
10. Avoid sending too many messages to people that can’t read them – full message boxes, blocked, etc.
11. Check your web application if it can’t be used to send spam for real. This might be a case for “send to a friend” forms or similar which allow information input. This is quite serious security issue as you might get blacklisted.

Overall, the most important factor is monitoring back all information you get back from emails you send, especially the “negative” one : bounced emails, sending errors and similar. There are lots of information in bounced messages that you should read and evaluate.

I have read a tweet about PHP programming today that made me furious.

“Handling complex logic in PHP is like doing the LSATs after shock therapy”

What is wrong with this statement? It moves responsibility from coder to the coding language and that is completely wrong in this case.

Firstly, PHP has syntax similar to C, which is used to code programs much more complex than most of websites. Almost all control statements are similar or same.  Although there are differences, I doubt anyone would argue that there is a significant lack of logic control statements in PHP than in C. Although PHP lacks specific PC programming libraries, it has very little to do with implementing logic of application.

So, what might cause such statements?

The top reason for problems handling logic is bad quality of the code (software quality measures how well software is designed (quality of design), and how well the software conforms to that design (quality of conformance)). PHP, similarly to C, is a very flexible language. And you need to and think work to produce good, quality code.

Thus, what is code quality characteristics related to implementing logic in PHP?

1. Separation of concerns. You should not handle logic, input, output, database, exceptions in single big file. Implement these as functions, or use libraries and frameworks. There is no excuse to not use a PHP framework nowadays, except when modifying old application source. And yes, I made such mistakes myself in the past.
2. Avoid logic shortcuts, like die(), exit() and break (in cycles, not in switch) statements if you can. They make code much harder to comprehend in the long run. Perfect function or method has a single return statement as well.
3. Use right model of computation to process information gathered. Logic will look nasty in all the languages as long as you have no foundation how to handle it. And the worst is, these programming models are already here for decades, like FSMs. Simply, they are used in software programming, but not so in web programming.
4. Comments, documentation, sane names of variables and no hacking. One of the reasons for bad code is “quick fixes”, when quick, undocumented fixes are applied to program code that no one understands later on. Even worse, they are applied to the system/framework core without any documenting sometimes. That might leave you stuck with un-updated version of some framework for long time.
5. It is better to comply with framework programming model than implement couple different models in single system. If you are using hook and plugin based framework as wordpress, stick to it, and know its features, internal logic and limitations.

If you will know these 5 things, all you will have to curse is your code or framework/cms you are using. But not the PHP.

2. Ability to integrate various things he learned in different environment. Few programmers learned MVC or frameworks at universities here. However, they have learned FSMs or some other paradigms that can be successfully applied in web development as well. Few try it though (Note: knowing more than one programming paradigm is a bonus).

Sometime we get a new inexperienced guy in a company as a programmer. Typically, we test them beforehand; however they are rarely perfect when started. Sometimes they are very new to programming or have bad habits from previous programming jobs. Thus it is my goal to help them to improve. And sometimes it gets really hard to integrate the guy into company. However there are some criteria that allow recognizing people with potential on becoming programmers and ones that are better left behind.

1. Persistence and knowing how to learn. Even more, urge to try and learn new things. I love programmers that know how to look for information on a problem.  Everyone can do a task they learned, but the best programmers know where to look for an answer and never give up without a good reason. The best way is to give a task they have no experience in and look how they are trying to solve it. If a person gives up prior googling for an answer, he will not be a programmer.
2. Ability to integrate various things he learned in different environment. Few programmers learned MVC or frameworks at universities here. However, they have learned FSMs or some other paradigms that can be successfully applied in web development as well. Few try it though (Note: knowing more than one programming paradigm is a bonus).
3. Ability to create a concise logical algorithm for solving a problem. You can be entry level web programmer without that, but that’s it.  Ability to draw these using some popular schematics like UML state diagram is a bonus.
4. Ability to debug code of other person. A programmer is unable to learn if he can’t dive into code of someone else and understand how it works. Sooner or later you will have to implement a similar algorithm where you will not be able to use that code as it is. This is closely related to ability to create algorithm.
5. Ability to write code other people understands. I loved one programmer that wrote nice functions for everything while coding a trivial task in PHP. Also, he commented a lot. Sadly, his interest was not web programming.

There is couple of reasons to develop site distributed under multiple subdomains, e.g. subdomain1.domain.com, subdoman2.domain.com, etc. Each subdomain might be a distinguishable mini-site, which offers better separation of topics and even protects main site rankings to some extent.

However, subdomain approach has one issue that needs to be solved. That is each subdomain is treated as separate site by some search engine spiders. This leads to insane amounts of concurrent hits. The worst offender is yandex – a Russian search engine whose spider scan list is probably alphabet based. Thus many of your minisites get scanned at the same time for content.

This might not be a problem if each of your minisites are hosted separately and not on the same server. Also, this would not be a problem if your subdomains are simplistic. In other cases you have to rely on your page caching and server capacity.

There is a crawl delay option that yandex listens to. However, this option can be set in robots.txt only. And robots.txt is subdomain-based. Thus it works for single subdomain only.

I have decided to totally block yandex from indexing one of my sites once. Luckily, this site can live from visitors from Russia, as it is geared towards different location. But now I doubt I would do a heavily multi-domain (300+ subdomains) site knowing that I will have to use yandex traffic as well.

Quite often I am hired to perform modifications in other web projects done by someone else.  This might be an unmaintained website bought ages ago, or when programmers mess up. It is tough to analyze your own code after couple of years from creation. It is much harder to analyze code of someone else. There are so many different programming styles. And most often the code is documented poorly. So, how to do it properly and save the time?

1. Gather all documentation of code if it is available. What framework or library was used? Was a CMS used? If so, you are in luck as these are more or less documented. Not always, though. If the basis used is branded as “software”, the documentation is typically lacking. It is assumed that you don’t need to modify ready to go software.
2. Try to map code on some known framework/pattern/approach. If there is clear separation from business logic, database tables and visual representation, you can try to approach the code using MVC. If there is separation between data processing and representation, then it is template based approach. Maybe the system is hook based? This will help to understand how programmers think. Worst kind of code is when business logic calls representation logic which calls some different business logic and so on. Then it might be a mess, especially if you can’t get why programmers decided to do so. Usually there is a different separation taking place between first and second layers of business logic, though sometimes this can be called “quick hack to output specific info” only.
3. Try to identify file deployment structure and write it down. Where are configuration files, templates, classes located? What is structure based on?
4. Draw a basic request scheme on paper. What files/modules the request passes till result is send to the user? This will help you to better understand the software.
5. Identify places you need to make modifications. The best help is simply stopping execution in various places of file and seeing what data you have at these places. Die(), echo and print_r are the best friends.
6. Stick to commenting out old code and commenting changes you make. Make it easy to undo your changes, and make it easy to understand what you have done.
7. Last, but not least, test everything.

Today I want to talk about really unproductive topic – that is how to code poorly. Or, more exactly, I am going to pick on my unfavorite  piece of social site again, that is Boonex. We will talk about how one should not implement user sessions and how to do it better.

Boonex uses unencrypted cookies to store session data, that is member ID and hashed member password. Each request Boonex checks database for memberID and password combination. This is to ensure that the person would be logged off the system if password is changed by someone else.

Thus, what is the problem with this approach?

Well, what about making hashed passwords save on PC user logs in? These passwords remain available till user explicitly logs out.  And the hash used is a simple md5 hash which is fast one-way function. You cannot reverse it, but it is susceptible for dictionary or brute force attacks. There are databases for such md5 strings as well.

You could partly solve that problem by using a seed with the hashed password. However, it would make the password guessing game more complex but not impossible. Also, you do not need the password for being logged in, just the cookies. And it is quite simple to change values in them with Firefox.

Another problem we had is with effectiveness of this password checking. It is one of multiple requests that are done on each page load. Even when they are fast, they affected boonex performance, which is quite bad anyways. But caching this information makes a security hole open:  ID could be changed and your system could be compromised.

It is much safer to save session information on server side.  PHP native session management is much better than what boonex has to offer, thus you should switch to it in the code (I have demo version of boonex  7 on August, it still has this problem).   It is quite some work, but it is worth it. Or, even better, look for some other social network script.

Google analytics does good job at monitoring pages visited, but what about pages that are not found on your server and thus never displayed? You can get these pages by moving the content around, having errors in your links, getting malformed links from various webmasters (often they are caused by bad software on their side or miscommunication) or for other reasons. Even a soft like wordpress does not check comment links, which might generate 404 errors (page not found). How to detect such links? Well, you have 3 choices, each of them have their own drawbacks.

1. Google webmaster tools. Adding your site to google webmaster tools is good idea, and there you will get information about links not found. It is most simple way, but worst as well. This is because Google detects the links that are linked and indexed. However, there might be plenty other links that need to be taken care of. For example, advertisement campaigns use non-followed (often javascript) links.

2. Log analysis. That is the best method if you have access to log files and you can process them. I prefer using Awstats for that, however you can do it by hand for smaller sites on apache, as errors are logged to separate file as well. The single problem with manual analysis is that error log has less information than common log. There is no referrer link mentioned in the error log. However, this can be solved by using grep to scan access log for 404 error codes as well. The drawback is that some CMS processes all requests and do not generate error codes successfully. This means that you will not see such errors in logs even if they exist.

3. If you can’t access error logs, the best way of action is to use custom error pages and create a log from them. You have to log both referrer path and request uri for best result. This approach can be implemented in many of the abovementioned CMS’es too.

So, what to do with bad links? This depends on what causes these links. If it is an advertisement campaign or a referrer site, you will have to create a redirect from bad link to the appropriate good one. In cases this is a malformed comment link, I would just delete it from database.

A traffic spike might be a joy for marketing department after successful advertising placement or a viral campaign. However, you will not be able to use up that traffic if your website is not loading properly. And that is quite common: no one likes to pay for more hardware than it is necessary during “normal operation”. I have seen major local news sites shutting down during such spikes, and had experienced such spikes myself as well. And it is up to whole IT team to solve the issue as fast as possible. So, what to do?

1. Identify what causes server problems and what one can do to improve. Typical bottlenecks are disk access, database query amount, http and mysql process limits, and memory amount available for all the processes.
2. Check what pages are hit heavily. This can be done by examining http server logs, or (at worst case) setting Google analytics date to current day. There are log analytic software, but you will probably see with the naked eye what pages occur most often. “grep” might help in this case too, by excluding images from your search.
3. Check if caching works as intended. Check if mysql cache is turned on (This is fast one, and quite important), and if enough memory is assigned to mysql cache. Mysql caching is switched off by default.
4. If it is possible, upgrade today. VDS upgrades can be done instantaneous. That is one of reasons I have started to love them. In other cases, it is not so fast, but you might get more memory installed quite quickly.
5. Tune the http process children amount (if you use Apache). You do not want to have more of them than fit into memory, remaining from system processes and mysql. Swapping these processes is a really bad idea. This might need to be adjusted if memory amount changes.
6. After doing easy stuff, time for more complex ones. You might have to implement easy version of page caching on heavily hit pages if this is feasible. If you code with PHP, this might be done with output buffer control module.
7. Done easy caching but still no improvement? If the problem is database, time to dig into database queries. Turn database logging on for minute or two, then revert for version without logging. Also, it is worth checking slow queries with slow query log at mysql. You have to identify a) Slow queries b) queries that repeat multiple times during the page load c) queries that return same information for majority of pages (for example, some static block like recent articles).  First type of queries should be rewritten if possible. Second type of queries should be eliminated by reusing the information. Third type of queries means that fragment of pages needs pre-cached elements.
8. As long as you look at the queries, check if there are multiple versions of the same queries. Rewrite them to look the same. Mysql can not cache queries if they are written differently (even when only case differs).
9. Also, you might want to turn some things off during peak times. Like page view counter (in worst case), some cron jobs.
10. Disk still heavily in use? Check if you can reduce how many http child processes are required to display the page. Move some elements to sprites. Or move images to different webserver if possible. Use single css file instead of multiple. And so on. It is worth considering using lighttpd for showing images instead of apache.

Overall, it is better to be prepared for traffic spike than be surprised by it. However, in lot of cases even on dire server loads there are things, that can be done so users would not notice any downtime and marketing campaign would not go in vain.

Anything else? Please comment bellow.

I had read a post at sitepoints about 16 php 5 frameworks. I will not argue the fact that frameworks are good and you should use one. What saddens me is that the key points of comparison are omitted in the post.

So, how to compare different php 5 frameworks? Let us see.

1. Paradigms used. Although MVC is mainstream now, it is not a single paradigm in php development. There are frameworks that are event based only. Additionally, there are different paradigms for different application layers, for example CRUD for database (model) layer, pretty well supported in php cake. Zend does not have module layer at all, you need to use your own database access, as example.

2. Modularity and reusability of framework. Although MVC provides modularity on controller- basis, additional modularity is required to re-use code between applications. This is important for developing bigger project that share modules.

3. Php version support. Some frameworks require specific versions of php5. This means that you have limited options for hosting.

4. Shared hosting support. You might need that before project kicks in. Some frameworks behave weirdly on shared hosting, as they need specific setup.

5. Proof of concept and maturity. Have you seen applications developed with the framework? Is framework developer community active or dormant? I would shun a framework without some real-world example sites.

Have something to add? Comment bellow!