{"id":463,"date":"2008-09-14T09:15:18","date_gmt":"2008-09-14T09:15:18","guid":{"rendered":"https:\/\/virtualchaos.co.uk\/blog\/2008\/09\/07\/to-smarty-or-not-to-smarty\/"},"modified":"2008-09-14T09:16:42","modified_gmt":"2008-09-14T09:16:42","slug":"to-smarty-or-not-to-smarty","status":"publish","type":"post","link":"https:\/\/virtualchaos.co.uk\/blog\/2008\/09\/14\/to-smarty-or-not-to-smarty\/","title":{"rendered":"To Smarty, or not to Smarty?"},"content":{"rendered":"

At Talis<\/a> we have been doing more than just our fair share of PHP development, in fact we are using the language to implement a number of new prototypes, products and services. One of the questions that I’ve been struggling with recently is whether or not we should be using the Smarty template engine<\/a>. Whilst we have used it with a measure of success on several projects, I’ve been struggling with what Smarty represents. Smarty is written in PHP and allows you to create templates that are marked up using Smarty’s own language syntax however this means that generated pages are precompiled at runtime down to pure PHP before being served. What strikes me is that Smarty is a Template Engine written in a language that was designed primarily for templating. So the question I’m left struggling with is: Why do you want to add the overhead of a secondary language to do what your first language already does and is fully capable of doing?<\/em><\/p>\n

The more I think about it, the more I’m convinced that the answer is that you dont! I’m going to try to explain why by examining some of the reasons that are often cited for using Smarty.<\/p>\n

Separating PHP from HTML<\/strong><\/p>\n

I’ve often heard his mantra, but I would describe it in a slightly different way and that’s by saying that what’s actually desired is to keep keep your “business logic” separate from your “presentation logic”, which is subtly different. If you accept that the two are indeed different then you should realise that all that\u2019s actually required is a way to keep your Views and Controllers separated which can be achieved using plain PHP in your view scripts (templates), without the overhead of having to add a new language into the mix.<\/p>\n

Easier to read<\/strong><\/p>\n

I’ve always struggled with this and here’s why … does anyone really think that this <\/p>\n

\n
    \n
  1. \n
     <\/div>\n<\/li>\n<\/ol>\n<\/div>\n

    …is really easier to read than its pure PHP equivelant? here … <\/p>\n

    \n
      \n
    1. \n
       <\/div>\n<\/li>\n<\/ol>\n<\/div>\n

      … I honestly don’t think that it is. I know that there’s a view in the community that there are front-end only Developers out there or Web Designers that shouldn’t have to learn PHP, but are they really better off being taught a different language? Firstly I’d question if there are actually Developers out there who know Smarty and don’t have an understanding of PHP, but for the purposes of this exercise lets assume that these mythical smarty only developers do exist then I have to confess I agree entirely with Harry Feuks1<\/a><\/sup> when he says<\/p>\n

      \n
      Walk them through a few sections of the PHP Language Reference\r\nand show them how PHP\u2018s control structures and simple functions like\r\necho() works and that\u2019s all they need.<\/pre>\n<\/blockquote>\n
       and also with Brian Lozier2<\/a><\/sup> who describes it much more convincingly when he says:<\/p>\n
      \n
      \r\nBasically, it just provides an interface to PHP with new syntax. When \r\nstated like that, it seems sort of silly. Is it actually more simple to \r\nwrite {foreach --args} than ? If you do think it's\r\nsimpler, consider this. Is it so much simpler that there is value in \r\nincluding a huge template library to get that separation? Granted, \r\nSmarty offers many other great features (caching, for instance), but it \r\nseems like the same benefits could be gained without the huge \r\noverhead of including the Smarty class libraries.<\/pre>\n<\/blockquote>\n
      Speed<\/strong><\/p>\n
      I’ve read several articles online that try to explain that there is a performance overhead when including Smarty. Yes I know you can cache your Smarty templates to improve performance in fact it’s not a question of ‘can’ it’s a question of ‘you really have to’ as Harry points out in the same article<\/p>\n
      \n
      if you hadn\u2019t chosen to write your own programming language\r\nand built an interpreter with PHP to parse it, you wouldn\u2019t have slowed\r\ndown your application in the first place!<\/pre>\n<\/blockquote>\n
      I performed a little test to try and illustrate what happens when you simple include Smarty, let alone actually use it. First off create yourselves a file called test.php and add the following line of code to it:<\/p>\n
      \n
        \n
      1. \n
        span class=”st0″>"Hello world"<\/span<\/div>\n<\/li>\n<\/ol>\n<\/div>\n
        Now let’s benchmark this using Apache Benchmark, thanks to Vivek  for providing some useful documentation on how to do this3<\/a><\/sup>. Open up a terminal window and issue the following command:<\/p>\n
        \n
          \n
        1. \n
           <\/div>\n<\/li>\n<\/ol>\n<\/div>\n
          Which on my system ( mac osx 10.5.2 4gb ram php5+apache2 ) resulted in the following:<\/p>\n
          \n
          \r\nnadeemshabir$ ab -c 10 -n 100 http:\/\/localhost\/test.php\r\nThis is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0\r\nCopyright 1996 Adam Twiss, Zeus Technology Ltd, http:\/\/www.zeustech.net\/\r\nCopyright 2006 The Apache Software Foundation, http:\/\/www.apache.org\/\r\n\r\nBenchmarking localhost (be patient).....done\r\n\r\n\r\nServer Software:        Apache\/2.2.9\r\nServer Hostname:        localhost\r\nServer Port:            80\r\n\r\nDocument Path:          \/test.php\r\nDocument Length:        11 bytes\r\n\r\nConcurrency Level:      10\r\nTime taken for tests:   0.58753 seconds\r\nComplete requests:      100\r\nFailed requests:        0\r\nWrite errors:           0\r\nTotal transferred:      19695 bytes\r\nHTML transferred:       1111 bytes\r\nRequests per second:    1702.04 [#\/sec] (mean)\r\nTime per request:       5.875 [ms] (mean)\r\nTime per request:       0.588 [ms] (mean, across all concurrent requests)\r\nTransfer rate:          323.39 [Kbytes\/sec] received\r\n\r\nConnection Times (ms)\r\n              min  mean[+\/-sd] median   max\r\nConnect:        0    0   0.5      0       2\r\nProcessing:     2    4   5.4      4      34\r\nWaiting:        1    4   5.5      3      33\r\nTotal:          2    5   5.3      4      34\r\n\r\nPercentage of the requests served within a certain time (ms)\r\n  50%      4\r\n  66%      4\r\n  75%      5\r\n  80%      6\r\n  90%      8\r\n  95%     14\r\n  98%     27\r\n  99%     34\r\n 100%     34 (longest request)\r\nNadeems-Computer:smarty-test nadeemshabir$\r\n<\/pre>\n<\/blockquote>\n
          So the important figures are Request Per Second: 1702.04<\/strong>, Time per request: 5.875 [ms]<\/strong> (mean),  Time per request: 0.588 [ms]<\/strong> (mean, across all concurrent requests) and Transfer rate: 323.39 [Kbytes\/sec]<\/strong> received. Now let’s create a new test file called test-smarty.php, and add to it the following:\n<\/p>\n
          \n
            \n
          1. \n
            span class=”st0″>’smarty\/libs\/Smarty.class.php’<\/span>"Hello world"<\/span<\/div>\n<\/li>\n<\/ol>\n<\/div>\n
            and run the same test again … <\/p>\n
            \n
              \n
            1. \n
               <\/div>\n<\/li>\n<\/ol>\n<\/div>\n
              which results in the following:<\/p>\n
              \n
              \r\nnadeemshabir$ ab -c 10 -n 100 http:\/\/localhost\/test-smarty.php\r\nThis is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0\r\nCopyright 1996 Adam Twiss, Zeus Technology Ltd, http:\/\/www.zeustech.net\/\r\nCopyright 2006 The Apache Software Foundation, http:\/\/www.apache.org\/\r\n\r\nBenchmarking localhost (be patient).....done\r\n\r\n\r\nServer Software:        Apache\/2.2.9\r\nServer Hostname:        localhost\r\nServer Port:            80\r\n\r\nDocument Path:          \/test-smarty.php\r\nDocument Length:        11 bytes\r\n\r\nConcurrency Level:      10\r\nTime taken for tests:   0.310262 seconds\r\nComplete requests:      100\r\nFailed requests:        0\r\nWrite errors:           0\r\nTotal transferred:      19500 bytes\r\nHTML transferred:       1100 bytes\r\nRequests per second:    322.31 [#\/sec] (mean)\r\nTime per request:       31.026 [ms] (mean)\r\nTime per request:       3.103 [ms] (mean, across all concurrent requests)\r\nTransfer rate:          61.24 [Kbytes\/sec] received\r\n\r\nConnection Times (ms)\r\n              min  mean[+\/-sd] median   max\r\nConnect:        0    2   4.7      0      17\r\nProcessing:     9   26  14.3     22      84\r\nWaiting:        8   25  14.1     22      82\r\nTotal:         13   28  14.7     24      87\r\n\r\nPercentage of the requests served within a certain time (ms)\r\n  50%     24\r\n  66%     28\r\n  75%     35\r\n  80%     37\r\n  90%     46\r\n  95%     70\r\n  98%     84\r\n  99%     87\r\n 100%     87 (longest request)\r\nNadeems-Computer:smarty-test nadeemshabir$\r\n<\/pre>\n<\/blockquote>\n
              \nNow we can see a dramatic difference those important figures are now –  Request Per Second: 322.31<\/strong>, Time per request: 31.026 [ms]<\/strong> (mean),  Time per request: 3.103 [ms]<\/strong> (mean, across all concurrent requests) and Transfer rate:  61.24[Kbytes\/sec]<\/strong> received. If you take simply the requests per second we are now only serving almost a sixth of the requests we originally served, and that’s without even using Smarty, that’s from just simply including the codeline!<\/strong>\n<\/p>\n
              Conclusions<\/strong><\/p>\n
              To my mind those results and the arguments I’ve cited are pretty emphatic, I can’t justify using a template engine that adds so much overhead when you can achieve the same results using a pure PHP implementation. This view seems to be widely held and accepted, it’s part of the reason why many other Template Engines like Savant<\/a>, Zend_View<\/a> and Solar_View<\/a> all embrace a different ethos to Smarty i.e they don’t compile your templates into PHP because they use PHP as the template language.<\/p>\n
              If you are at all unconvinced by the arguments I’ve presented then like me you might want to consider the words of Hasin Hayder<\/a> who is the author of the popular book Smarty PHP Template Programming and Applications<\/a> which I own a copy of :). He also created this Smarty Cheat Sheet<\/a> which I along with several of my colleagues have copies of on our desks. Earlier this year Hasin wrote an article entitled Once upon a time there was Smarty<\/a>, in this article Hasin touches on many of the points that I and others have made, and whilst the depth of my knowledge of smarty could easily be challenged Hasin is without question an expert, so he when he said …<\/p>\n
              \n
              \r\nI seriously don\u2019t think there is need of Smarty anymore. Its dead! If \r\nyou guys don\u2019t agree with me, you can spend hell lot of time learning \r\nthat {$name} actually does what you could do with \u201cecho $name\u201d. If \r\nyou write a dispatcher which is smart enough to bring the variables \r\nfrom a controller scope to the scope of a view, why do u need to learn \r\na separate parser like smarty? ... Learning all those functions, loops, \r\nlogics, caching and others in smarty takes so much time that I would \r\nlove to suggest you to learn writing efficient PHP code in template layer \r\nrather than learning something like smarty ...<\/pre>\n<\/blockquote>\n
               … I stopped and listened … and then I found myself agreeing with his closing statement … <\/p>\n
              \n
              Sometime it\u2019s better to realize thats its time to unlearn something.<\/pre>\n<\/blockquote>\n
              1. phpPatterns, http:\/\/www.phppatterns.com\/docs\/design\/templates_and_template_engines<\/a>[back<\/a>]<\/li>
              2. Template Engines, http:\/\/www.massassi.com\/php\/articles\/template_engines\/<\/a>[back<\/a>]<\/li>
              3. How to performance benchmark a web server, http:\/\/www.cyberciti.biz\/tips\/howto-performance-benchmarks-a-web-server.html<\/a>[back<\/a>]<\/li><\/ol>","protected":false},"excerpt":{"rendered":"
                At Talis we have been doing more than just our fair share of PHP development, in fact we are using the language to implement a number of new prototypes, products and services. One of the questions that I’ve been struggling … Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":4,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[24],"tags":[124,399],"class_list":["post-463","post","type-post","status-publish","format-standard","hentry","category-development","tag-php","tag-talis"],"_links":{"self":[{"href":"https:\/\/virtualchaos.co.uk\/blog\/wp-json\/wp\/v2\/posts\/463","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/virtualchaos.co.uk\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/virtualchaos.co.uk\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/virtualchaos.co.uk\/blog\/wp-json\/wp\/v2\/users\/4"}],"replies":[{"embeddable":true,"href":"https:\/\/virtualchaos.co.uk\/blog\/wp-json\/wp\/v2\/comments?post=463"}],"version-history":[{"count":0,"href":"https:\/\/virtualchaos.co.uk\/blog\/wp-json\/wp\/v2\/posts\/463\/revisions"}],"wp:attachment":[{"href":"https:\/\/virtualchaos.co.uk\/blog\/wp-json\/wp\/v2\/media?parent=463"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/virtualchaos.co.uk\/blog\/wp-json\/wp\/v2\/categories?post=463"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/virtualchaos.co.uk\/blog\/wp-json\/wp\/v2\/tags?post=463"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}