Client vs. server rendering: are you still using ASP, MVC, JSP, or other?

Being a back-end programming expert, I was always leaning towards the server-side template based rendering. However, a while ago, after working with numerous client-side templating engines and weighing all pros and cons, I finally decided to switch most of my web apps to the pure JavaScript driven templated UI. While there are tons of existing frameworks for this, and some of them work really well, there are several reasons that pushed me to roll out my own client-side template rendering solution. Working with other frameworks I always had a feeling that there was an easier solution. DOM based libraries flood your HTML templates with dummy elements and attributes, making it hard to read, plus performance suffers from heavy DOM transformations. Client-side MVCs and compiled templates are very interesting, but say goodbye to clear WYSIWYG markup :) Plus the framework with the compiler themselves are huge, plus the need of  extra frameworks for debugging all this, plus long learning period. In my opinion, this all is much more over complicated than it should be. And likely this complexity is visible to all those devs who hesitate to use client-side rendering and prefer to stick with MVC4 Razor, PHP, and others.

I always say “simple must stay simple” (slogan on my dev site :), and I’m writing this post to share my own client templating solution that I came up with after using other framework. On one hand, this new solution allows to render the output of unlimited complexity. On the other hand, it is stupidly and unbeatably simple. It’s simpler than you can imagine :) The whole library is about 100 lines of code, it’s super efficient, it consists of two functional primitives, and you literally have to spend 2 minutes to learn it.

Oh yes, I know how this sounds Smile The other part of me had the same reaction when my dark side came up with this rendering solution. So, let me guide you through the approach, do some good examples, and demonstrate how it all works.

Table of Contents


The idea of generating HTML output by executing JavaScript against JSON and client-side template is not new. For at least 5 years it was a continuous discussion whether back-end application task should be reduced to providing JSON data only, leaving rendering task for the client-side. After pushState() feature of HTML5 came out, many devs started leaning towards the client-side more and more.

I started working with client-side from using JSONDataSet from Adobe Spry framework. It’s a DOM based library that works pretty well for certain tasks, but it’s not capable of doing fully custom output. Then I used JavaScriptMVC, Knockout, Angular, and some others from this list here. I liked MVC and compiled JS templates for flexibility and customization. I suggest you take a look at the frameworks I listed in order to feel how the solution below is different from them. However, there are reasonable opinions that if, for example, client-side MVC syntax does not make it much simpler in terms of programming, why not just use server-side MVC4 or PHP5 to achieve the same? Moreover, server-side debugging is a way more convenient. Yes, client frameworks can do a lot, but why bother switching from our lovely sever-side, unless there is some glaring programming benefit?

In this short article I’ll show that there is actually a huge benefit and many good reasons to switch. I’ll propose the solution that DOES make programming simpler and more flexible. It makes it almost trivial actually, so every graphics designer with knowledge of JavaScript can do page rendering like senior expert. This raises another interesting question – if the entire complex server-side rendering mechanism can be replaced with trivial JavaScript, do we need server page frameworks (ASP, MVC, PHP, whatever) at all? Sounds scary, huh?

OK, let me now introduce my simple solution to client-side template rendering.


Assume we have some JSON data on the web page. There are several good options to load JSON, but the best practice is to include JSON data within the page on initial page load (i.e. no extra Ajax call needed) and then use async Ajax to update parts of JSON data on demand. But this is offtopic here, so we just assume that JSON is already available.

Now, what’s the best way to build HTML based on this JSON? After thinking about this with a pen and a paper, I came to the conclusion that, speaking abstractly, every possible rendering task can be accomplished as a random combination of two functional primitives:

  • repeat – repeats fragment of HTML code for each object in array
  • toggle – shows or hides fragment of HTML depending on boolean flag

I call this solution jsRazor, because it shaves off all redundant complexity. Any crazy UI design that you ever come up with, you can achieve by combining only two functionals in different nesting configurations.


The key part of our solution is the template and the way jsRazor works with it. Same principle “simple must stay simple” is applied here: jsRazor does not do DOM transformations, JS compilation, or anything like this. The template is entirely treated as plain text and all transformations are simple search-replace-insert operations over the string object. There is nothing in JS world that could be more efficient than this!

Typical jsRazor template looks like the following:

some HTML
  HTML fragment to repeat 
  plus value placeholders {Value1}   
    nested HTML fragment to repeat 
    plus value placeholders {Value2}
  more HTML
    HTML fragment to show or hide
  more HTML here
more HTML here

So, everything is very simple here. To mark target fragment for repeat function we use <!–repeatfrom:name–> and <!–repeatstop:name–> comment limiters. For toggle function, use <!–showfrom:name–> and <!–showstop:name–> limiters. To output actual values, use placeholders of {SomeValue} format. Now, combine these two simple functionals in any possible configuration and get the desired output. For example, to achieve logical OR on toggle, you put two or more toggles beside each other; for logical AND, you nest one toggle into another. And so on.

The good thing about comments is that they don’t interfere with your HTML and do not break WYSIWYG experience. Comment limiters are used by default, but you can change them to any format you like (see next section). Sometimes you want do deliver your template wrapped inside a comment itself, so that setup scripts do not touch the template. In this case you’d need to change limiter format to something other than comment.

Now let’s see the actual functions that do all work.


As I stated before, jsRazor consits of only two functions to accomplish all work. I decided to create them as jQuery plugin in jsrazor namespace. This is just because I like jQuery plugin syntax, but there is no actual framework dependency. Although I’ll use jQuery in my examples, the plugin will work fine without jQuery library. Let’s see the actual call syntax and parameters.

First, there is one setting that you can use to change limiter format. To use [repeatfrom:name] format instead of comments, you’d have to do the following:

$.jsrazor.settings.limiterFormat = "[{type}:{name}]";

And now let’s look at the functions. First one is repeat:

$.jzrazor.repeat(template, name, items[, render])
Description Repeats the fragment surrounded by limiters inside the template
Returns The resulted rendered content
  • template (Type: string): Plain text template that contains fragment to repeat.
  • name (Type: string): Name token that identifies fragment limiters e.g. <!–repeatfrom:name–> and <!–repeatstop:name–>
  • items (Type: Array): The array of objects of any type that repeater will iterate through.
  • render (Type: Function(string tmp, Number idx, Object item)): Optional rendering callback invoked on every iteration to return rendered content for current item. Parameter tmp contains the template for current item. Parameter idx is the position of item in the items array passed to the original function call. If current item is JSON object, then values of its properties of string or Number type are output to {<property-name>} placeholders. If current item is of string or Number type, then its value is output to {item} placeholder. Note that automatic output of properties into placeholders is done by plugin AFTER the rendering callback returns. 

In other words, inside render callback you process content passed in tmp and return the desired output for the current item. All item properties are output to {<property-name>} placeholders automatically. To insert custom values, I suggest usage of placeholders in {SomeValue} format replaced with string.replace(..) function, but you can choose any format at your own preference. There is no limitation on processing inside the callback, so you can achieve any custom output you like.

Second function is toggle:

$.jzrazor.toggle(template, name, flag)
Description Shows or hides the fragment surrounded by limiters inside the template
Returns The resulted rendered content
  • template (Type: string): Plain text template that contains fragment to toggle.
  • name (Type: string): Name token that identifies fragment limiters e.g. <!–showfrom:name–> and <!–showstop:name–>
  • flag (Type: Boolean): Should be true to show fragment, and false to hide it.

Everything is trivial here. If flag is true, then fragment stays (limiters are removed). Otherwise, both fragment and limiters are removed.

Now let’s just think for a moment. Two JavaScript functions instead of the entire ASP.NET, PHP, JSP, etc. rendering mechanism! All those server controls, control flow statements, binding expressions, page lifecycle, etc. etc. suddenly just become redundant. In terms of 3-tier web app design, the entire presentation goes away to the client-side. Server-side is left with data layer and the business logic, and only needs to generate JSON data feeds.

Sounds good, doesn’t it? Now it’s time to see this all in action!


I’ll use same JSON data as Adobe Spry uses for their demos – I hope they don’t mind :) So, assume that JSON is created on the back-end from our data layer and is delivered to the client-side. Here are some good examples.

Example 1

Assume we have an array of simple JSON objects describing  colors:

var data_Colors =
	  color: "red",
	  value: "#f00"
	  color: "green",
	  value: "#0f0"
	// ...

We want to output the colors as comma separated names followed by hex values in brackets. Here is the desired output:


I do identical output twice just to demonstrate slightly different JavaScript syntax:

<div class="cont-ex1">
    1) <!--repeatfrom:colors1-->{color} ({value}), <!--repeatstop:colors1-->
    2) <!--repeatfrom:colors2-->{color} ({value}), <!--repeatstop:colors2-->

There are 2 repeaters here beside each other: colors1 and colors2. They both will do the same, but with little different code just demonstrate one feature to you. Now let’s see the actual JavaScript:

var $cont = $(".cont-ex1");
  var output = $cont.html();
  output = $.mksft.repeat(output, "colors1", data_Colors); // most basic default repeater
  output = $.mksft.repeat(output, "colors2", data_Colors, function (tmp, idx, item) { return tmp; });

All we do here, we get the template from inner HTML of some element, process it, and insert the result back. I use jQuery to work with inner HTML, but, as I mentioned earlier, plugin itself does not depend on any framework.

In our case, template is taken from inner HTML of <div class=”cont-ex1″> container and assigned to output variable. First, we apply colors1 repeater to it on line 4. Notice that optional render callback is omitted, so there is no custom processing, but only automatic placeholder replacement based on JSON object properties. In the template we used {color} and {value} placeholders which will be replaced with color and value properties of current item on each iteration.

On line 5 we apply second colors2 repeater. The only difference is that I included render callback this time. All this callback does, just returns the current item template without modifications, which is essentially the same as omitting the callback for colors1 repeater.

Example 2

One more basic example. Assume we have an array of values:

var data_Numbers = [100, 500, 300, 200, 400];

We want to output them as following:


Template is simple:

<div class="cont-ex2">
  <div><!--repeatfrom:numbers-->{item}, <!--repeatstop:numbers--></div>

The JavaScript code is even simpler:

var $cont = $(".cont-ex2");
  var output = $.mksft.repeat($cont.html(), "numbers", data_Numbers);

No need for render callback here. Recall from API, when current item is of string or Number type, then its value automatically output into {item} placeholder. Done.

Example 3

In this example let’s do some custom processing. Our data is the same array again, but this time, for each number N in the array we want to output N-1<N<N+1. Here is the desired output:


For N-1 and N+1 values we will need custom placeholders. We don’t want trailing comma after the last item as it was in our previous examples. To accomplish this, we will need to use the fragment toggle. Here is the template:

<div class="cont-ex3">
    {ItemL}&lt;{item}&lt;{ItemM}<!--showfrom:not-last-->, <!--showstop:not-last-->

In this template we have {ItemL} and {ItemM} extra placeholders. Also, comma is wrapped into the not-last toggle and will be displayed only when current item is not last one in the array. Now let’s see the code:

var $cont = $(".cont-ex3");
  var output = $.mksft.repeat($cont.html(), "numbers", data_Numbers, function (tmp, idx, item)
    // toggle conditional area
    tmp = $.mksft.toggle(tmp, "not-last", idx < data_Numbers.length - 1);
    // custom placeholders
    tmp = tmp
      .replace(/{ItemL}/g, (item - 1))
      .replace(/{ItemM}/g, (item + 1));

    return tmp;


OK, now it’s more interesting, because render callback has some processing in it! On line 3 we apply numbers repeater as before. Then, render callback needs to return rendered result for every item. On line 6 we apply not-last toggle to the fragment with comma. Recall that 3rd parameter is flag that needs to be true to show the fragment, so in our case it is true when item is not last one in the array. Then, on lines 8-10 we output our custom placeholders by simple string.replace(..) operation. Value of item equals current item in the input array i.e. in our case it an integer number.  That’s all.

Example 4

And the last example for today is the complex JSON with multiple nested arrays that require nested repeaters to output them. We will need to combine them with several fragment toggles to achieve even more custom output. Here is a JSON describing donuts menu:

var data_Donuts =
        "id": "0001",
        "type": "donut",
        "name": "Cake",
        "ppu": 0.55,
            { "id": "1001", "type": "Regular" },
            { "id": "1002", "type": "Chocolate" },
            { "id": "1003", "type": "Blueberry" },
            { "id": "1004", "type": "Devil's Food" }
            { "id": "5001", "type": "None" },
            { "id": "5002", "type": "Glazed" },
            { "id": "5005", "type": "Sugar" },
            { "id": "5007", "type": "Powdered Sugar" },
            { "id": "5006", "type": "Chocolate with Sprinkles" },
            { "id": "5003", "type": "Chocolate" },
            { "id": "5004", "type": "Maple" }
      // ...
        "id": "0004",
        "type": "bar",
        "name": "Bar",
        "ppu": 0.75,
            { "id": "1001", "type": "Regular" }
            { "id": "5003", "type": "Chocolate" },
            { "id": "5004", "type": "Maple" }
            { "id": "7001", "name": "None", "addcost": 0 },
            { "id": "7002", "name": "Custard", "addcost": 0.25 },
            { "id": "7003", "name": "Whipped Cream", "addcost": 0.25 }
      // ...

Here is the output we want to achieve:


Here is a template to achieve this:

<div class="cont-ex4">
    <li>[{id}] | {type} | <b>{name}</b> | ${ppu} 
            <li>[{id}] {type}</li>
          <span style="color:brown;">
             {CountChocolate} chocolate toppings available
            <li>[{id}] {type}</li>
            <li>[{id}] {name}
              <span style="color:red;font-weight:bold;">+${addcost} = ${NewPPU}</span>

So, to output our hierarchical data we want to use nested HTML lists. First level outputs donuts and their direct attributes using donuts repeater on lines 3-40. Second level outputs batters (lines 8-10), toppings (lines 20-22), and fillings (lines 28-34) arrays. Some donuts do not have fillings, and in this case we want to show nothing instead of showing “Fillings” title with empty list. To achieve this, we enclose the entire fillings section in the has-fillings toggle on lines 25-37. Next, some fillings add extra cost to PPU. When this is the case, we want to output extra amount in red font using “+$X=$X1” format where X is extra cost and X1 is the updated PPU. For this purpose we have cost-extra toggle on lines 30-32 and custom {NewPPU} placeholder. Finally, if there are any chocolate toppings available, we want to show a message like “2 chocolate toppings available”. For this purpose we have another has-chocolate toggle on lines 14-18 and {CountChocolate} placeholder. And this is all for the template! Now let’s see the code:

var $cont = $(".cont-ex4");
  // first level repeater for all donuts
  var output = $.mksft.repeat($cont.html(), "donuts", data_Donuts.donuts, function (tmp, idx, item)
    // default repeaters for batters and toppings
    tmp = $.mksft.repeat(tmp, "batters", item.batters);
    tmp = $.mksft.repeat(tmp, "toppings", item.toppings);

    // display fillings only if there any
    tmp = $.mksft.toggle(tmp, "has-fillings", !!item.fillings);
    // render fillings list
    if (item.fillings)
      var ppu = item.ppu; // save ppu for child value scope
      // custome repeater for fillings to display extra cost and new PPU
      tmp = $.mksft.repeat(tmp, "fillings", item.fillings, function (tmp, idx, item)
        // display price warning if there is additional cost involved
        tmp = $.mksft.toggle(tmp, "cost-extra", item.addcost > 0);
        // custom placeholder to display new PPU value
        tmp = tmp.replace(/{NewPPU}/g, ppu + item.addcost);
        return tmp;

    // display number of chocolate toppings
    var countChoco = 0; // count number of chocolate toppings
    $.each(item.toppings, function (idx, item) { if (/chocolate/i.test(item.type)) countChoco++; });
    tmp = $.mksft.toggle(tmp, "has-chocolate", countChoco > 0); // show/hide chocolate message
    tmp = tmp.replace(/{CountChocolate}/g, countChoco); // render chocolate topping counter

    return tmp;


Note that due to JavaScript variable scoping, I can re-use tmp, idx, and item variables in all nested repeater render callbacks, which saves a lot of code lines.

So, outer donuts repeater we have on line 4. Render callback starts from applying nested batters and toppings repeaters on lines 7-8. We leave them default, since we only need to output property placeholders. Next, on line 11 we apply our has-fillings toggle to hide the entire fillings area if there are no fillings. And if there are fillings, we output them applying fillings repeater on line 17.  On line 15 I have to save PPU value into separate ppu variable, because item will have different meaning in the render callback or the nested repeater. Inside render callback for fillings repeater I start from applying cost-extra toggle on line 20. Then on line 22 I output value for {NewPPU} placeholder. Finally, we need to deal with chocolate toppings. We count them on lines 28-29, apply has-chocolate toggle on line 30, and output count on line 31. We’re DONE!

I think you got the idea. Combining two simple functions you can achieve output of any complexity based on JSON of any structure – that’s all. The template is as simple and transparent as it can be. Comment limiters do not interfere with HTML leaving your template markup absolutely clean and viewable in any HTML editor. I don’t see any reason to use compiled templates when you can achieve here all output you need in a stupidly simple way.

Now it’s time to summarize everything we’ve seen so far.

Client-Side Solution Summary

I’ll not go deeply into general pros and cons of client-side rendering, because it was spoken already thousand times. Instead, I’ll mostly focus on the aspects specific to jsRazor solution.

Learning period

Seriously, how long did it take to read Solution and Examples sections above? 5 minutes? 10? And that’s all you need to know about jsRazor. There is no learning required here, while other client-side rendering frameworks might get quite complex. For example, JS MVC requires quite a bit of learning plus extra framework to debug you views. I’m not even mentioning server-side like ASP.NET here, where it takes several years to become rendering expert and learn all peculiarities of the server controls. Here, after 10 minute tutorial literally every HTML designer becomes able to build apps with flexibility that no server-side framework can achieve!

Development process

Look at our last example. Having that JSON data, it would take you 10 minutes to create the template and 5 minutes to write the JavaScript, agreed? It’s trivial and transparent. Just for comparison, how long would it take you to do the same in ASP.NET, MVC, JSP? You’d probably use some monster like DataGrid?  MVC Razor would take less than classic ASP.NET, but still much more than jsRazor. Now, what about client-side? Compiled templates and JS MVC would do the job, but syntax and simplicity would not be even close to jzRazor solution. Here is the list of client MVCs that you can take a look for comparison.

Developer skill level

Due to overall simplicity, jsRazor rendering task can be accomplished by HTML designer with basic knowledge of JavaScript. Furthermore, to maintain the already existing solution even lower skill will fit. The back-end developer gets involved only when there is need to create new JSON feeds or modify existing ones, which also does not require much framework knowledge. On the other hand, creating a regular server-page site requires senior programmer from the beginning, and at least a medium level programmer to maintain the existing solution. The client-side MVC also requires advanced developer, especially for debugging the code.


Application architecture is where jsRazor wins everywhere! First of all, if back-end is used only for generating JSON, this automatically means 100% presentation separation. Second, jsRazor also provides separation on the client-side! Look, in compiled templates you have your code mixed with HTML markup everywhere. Then compiler turns it into executable JavaScript. In jsRazor template is separate and code is separate just by design. Absolutely separate. So it’s double separation here: back-end separation plus front-end template/controller separation.

It was also noted many times by other IT experts that client-side rendering provides the maximum theoretical level of client-sever app simplicity. With trivial jsRazor templates this feature becomes even more obvious. No matter how complex your UI functionality is, on the back-end it’s always a bunch of JSON endpoints, and on the front-end it’s always a bunch of simple templates with tiny JavaScript controller (if I can call it this way).

What about performance?

Number one concern that comes to our mind about client-side rendering is performance. There are usually 2 arguments that I hear against client-side rendering in general: need for JSON data call on initial page load, and need for executing a bunch of JavaScript before page is displayed.

Regarding Ajax call on the initial load, I already mentioned that it is not really needed if application is written properly. Initial JSON has to be inserted into the page and loaded together with it, so it’s available without any additional calls, and Ajax should be used to update existing JSON or load extra data. So there is no problem here. It’s just a design consideration that every developer have to keep in mind.

Next question is how bad is it to execute JS to finalize page UI? Well, I would say that today, when tiny smartphones are capable of doing FullHD playback, this concern becomes negligible. Just to understand what we’re talking about here, let’s see the use case. I’ll use ASP.NET here as example, but results are true for other frameworks too, because, in terms of workflow, they all are pretty much the same.

Page rendering consists of a number of steps. Let’s depict the steps in the period between client request hitting the page and the page is displayed in the user browser. The picture is below:


There are more steps in a real world, but this is just a model. So, request passes through IIS and gets to ASP.NET. Then there is some housekeeping to run modules, setup context, etc. Then page begins lifecycle execution: usually we get entities from data layer and process them through some business logic. Then page is rendered (time spent is tR). Then housekeeping again, and then response is sent back to client through the network (time spent is tW). After it reaches the client, it’s displayed in the browser. If jsRazor rendering is used (time spent is tR*), then it has to execute before the page is displayed. Let’s call “case A” the case where pure server-side rendering is used, and “case B” – where jsRazor client-side rendering is used instead.

In case A, there is only tR. In case B – only tR*, because tR entirely goes away. So, roughly, it comes to comparing tR and tR*, right? I did not do any actual benchmarking here, so let’s just think theoretically. To render the server-page (the tR), ASP.NET builds control tree, goes through it, calls entire lifecycle for each control, etc. – a lot of work. However, this is all compiled code on the server, so, unless the page is really crazy complex, the rendering should be fast. On the other hand, tR* is taken by browser JavaScript. The entire rendering procedure of jsRazor is based on simple string operations, so it should be a way more efficient. However, it runs in the browser and JavaScript is slower than compiled code. So, intuitively I think that tR<tR*, but I’ll try to do actual benchmarking in the future. Anyway, even if this is the case, this is still NOT a concern, because it’s not going to be visible to the eye anyway.

If we think further, we may notice that tW for case B is actually less than tW for case A. This is because in case B, the response is a raw page with templates and JSON, but in case A, it is a completely rendered web page which is much larger. And the bigger your data grid is, the bigger will be the difference between tW in both cases. So, jsRazor approach gives much better performance in this terms. For slow internet connections this could be a big win actually.

Also, there is a benefit for server load, since we just take a large part of processing off the server. We can go further and say that there is no need to use ASP.NET for generating JSON and use web services instead. This would take even more load off the ASP.NET.

Caching is something where server-side rendering will be faster. Whether it is ASP.NET page cache or network level cache (CDN), for case B we only can cache the raw pages and JSON data, which means that tR* is always involved. In case A we cache fully complete pages that do not need any processing. So, under these conditions, case A will be tR* faster than case B. This is something to mention, but NOT a big deal at all. Again, in case of trivial JavaScript string operations that jsRazor does, tR* is negligible.


Of course, there are certain types of applications that may require server-side rendering only. Paradigm shift is always hard to accept, but for regular Web 2.0 apps (e-commerce, portals, social apps,  etc.) it seems like pure client-side rendering in general and particularly jsRazor is a much simpler and more flexible solution. A huge part of server-page framework can be replaced with two tiny JavaScript functions – is not it cool?

Also consider another important side of this. A part of work that was usually done by back-end developers, can now be done by HTML designers! This is actually very good, because it means more division of labour within the development team, and more spare time for busy senior dev team members :)

Visit jsRazor page for download links and more info.


Software Architect with over 15 years in IT field. Started with deep math and C++ Computer Vision software. Currently in .NET and PHP web development. Creator of DaST pattern, open-source frameworks, and plugins. Interested in cutting Edge IT, open-source, Web 2.0, .NET, MVC, C++, Java, jQuery, Mobile tech, and extreme sports.

Posted in open-source projects Tagged with: ,
34 comments on “Client vs. server rendering: are you still using ASP, MVC, JSP, or other?
  1. Wow – I am simply blown away by jsRazor. Nice work. I hope you don’t mind, I wrote a post on my blog

    For a long time I have played around with the idea of creating reports with jQuery. With jsRazor this may be much easier.

    • rgubarenko rgubarenko says:

      Sure, it’s great that you posted about it. There is another version of jsRazor coming in the end of May which might be even more useful for interactive reporting. Watch for updates.

  2. The Money Advice Service, payday loans a government-backed website,
    asked people a series of proposed regulations that, if passed,
    would put a cap on sky-high interest rates. So maybe you maybe
    make $1, 500 every two weeks until the loan is not payday loans a scam is
    they explain the entire process to a person.

    Feel free to visit my web page :: fast cash advances 45238

  3. What a data of un-ambiguity and preserveness of valuable familiarity concerning unpredicted emotions.

    Also visit my web site … empower network

  4. storage vps says:

    Hi my loved one! I wish to say that this article is amazing, great written and come with approximately all significant infos. I would like to peer extra posts like this .

  5. Because the admin of this web site is working, no uncertainty very shortly it will be well-known, due to
    its feature contents.

    my weblog; reseller hosting

  6. Valuable information. Lucky me I found your web site by chance, and I am
    surprised why this coincidence didn’t took place earlier!
    I bookmarked it.

  7. Ahaa, its good dialogue on the topic of this paragraph at this place at
    this blog, I have read all that, so at this time me also commenting

  8. Dakota says:

    I see you share interesting content here, you can earn some extra cash,
    your website has huge potential, for the monetizing method,
    just type in google – K2 advices how to monetize a website

  9. Wendi says:

    I read a lot of interesting posts here. Probably you spend
    a lot of time writing, i know how to save you a lot of time, there is
    an online tool that creates readable, SEO friendly articles in seconds, just type in google
    – laranitas free content source

  10. Elden says:

    I read a lot of interesting articles here. Probably you spend a lot of time writing,
    i know how to save you a lot of work, there is an online tool
    that creates high quality, SEO friendly posts in minutes,
    just search in google – laranitas free content source

  11. There’s definately a great deal to find out about this
    topic. I like all of the points you made.

  12. Makayla says:

    Awesome content. You should use social websites to increase
    traffic. There are tools which automate this time consuming process.Visitors can flood your page in no time, just
    search in google for:
    Rixisosa’s Social Automation

  13. the guide of Given that you’ve got the basic principles of responsive layout along, you exercise several of the popular
    format style styles utilized across sites and ‘ll learn about.

  14. It is not my first time to visit this web site, i am browsing this
    web site dailly and obtain good information from here
    all the time.

  15. Genevieve says:

    When getting rid of drain clogs, avoid using chemical cleaners.
    Their payloads are spread out over the entire dump body in order to maintain the weight requirements of the federal bridge laws.
    While both parents were charged, one of the charges that the boy’s mother is
    facing is more serious than what the boy’s father
    is facing, according to WUSA-9 on April 3.

  16. Judi says:

    Because of this capability, this equipment
    is mainly used in drainage cleaning where solids have already mixed in with
    the fluids. In other words, structures would be designed or modified to collect the natural rainfall that falls onto the
    property, purify it and then store it in cisterns until the water is needed by the occupants of the building.
    Many of the Earthships have propane tanks for cooking and a backup hot
    water supply; these are the only utility bills.

  17. Reed bed technology has a low price of entry and minimal daily functional and upkeep costs.
    Pipes and fittings are often made of the same base material such as copper, steel, polyvinyl chloride (PVC),
    and chlorinated polyvinyl chloride (CPVC).

    These microbes will settle in the tank and digest the waste in the tank.

  18. Esmeralda says:

    Reed bed technology has a low price of entry and minimal daily functional
    and upkeep costs. Pipes and fittings are often made of the
    same base material such as copper, steel, polyvinyl chloride (PVC),
    and chlorinated polyvinyl chloride (CPVC). Tiny video cameras are sometimes used to probe intricate pipes to
    pinpoint hidden leaks and problems.

  19. są nieodporne opowiedzieć sumę scen małżeńskich, równocześnie spośród samodzielnymi,
    jeśliby biorą iż upodobanie się na nie sprowadzi im wskazaną pomyślność.

    Istnieją szatańsko nieczułe i jeśli właściwie rzeczone
    umiem ukraść – niezmienne. W 4 wypadkach na 5 przystępnie ciekawe postępowaniem zleceń do zarobionego grosza.

  20. Blake says:

    Many consumers are also under the impression that supplements
    are inherently ‘natural’ and safe, but the lack of
    regulation surrounding the testing, manufacturing,
    and labeling of supplements can lead to potentially harmful products.
    Before we can start talking about diet pills that actually work, we need to establish the criteria to judge them by.
    You may think that purchasing vegetables at a farmers market is healthier but you must be
    sure they use organic farming methods otherwise you may as well go to the local

  21. Mackenzie says:

    Here at Createch we have made a variety of supplements, several of which are intended to do an exact job with your
    body. Excess consumption of zinc may cause bleeding
    stomach and severe abdominal pain. Do a simple search on Google or Amazon for
    a keyword like “dog supplements” and instantly you will get hundreds of
    thousands of results.

  22. Claribel says:

    Brain O Brain capsules tackle stress and produce high level of energy,
     the herbs used in the preparation of these capsules contain iron in high amount which enhances the capacity oxygen carrying of the blood by increasing the number of red blood cells.
    Its member companies manufacture popular national brands as well
    as the store brands marketed by major supermarkets, drug stores
    and discount chains. Another important fact why this disease is treated differently
    from conventional illnesses and why adrenal fatigue supplements
    are different from conventional medicine lays in the spectrum which it
    deals with.

  23. Dustin says:

    Make money on autopilot is available for all of us.
    Not only do you want lots of people to visit your website but you also want your visitors
    to stay on your site and see if the deal is worthwhile by
    simply checking out your site. I discovered the way to make money on the internet.

  24. Tamie says:

    It won’t necessarily cost less to get your site this way, but it does provide a way to spread the cost over time.
    I set an example of such information to demonstrate the formatting of a typical contact page as shown below:.
    Once each item on the list of services is defined,
    select all of the individual items for that list, click the Home tab on the ribbon and
    choose Bullets again to turn the bulleted list formatting back on for
    that block of text as shown below:.

  25. Carroll says:

    Most of the card dealers sell their cards online through websites that specialize in international calling cards.
    No software to buy, no code to learn, all you need is to
    be a little Internet savvy and know how to click your mouse.
    The website templates are well-equipped with HTML coding
    which could result into better looking websites in minor budget also.

  26. Sam says:

    The website will also serve as a portal for all things convention related, from a countdown clock to information on logistics, credentials, media walkthroughs and housing.
    This shows you how user friendly these templates are. Incompatibility: Rails’ structured and organized approach can be its strength as well as weakness in terms
    of flexibility and compatibility.

  27. Chasity says:

    As you keep implementing content marketing strategies,
    which is actually sharing quality information, then your visitors will keep on coming
    back for more. Small claims court cases are much cheaper than superior court cases for both the plaintiff
    (the person doing the suing) and the defendant (the person being
    sued) because the parties are not allowed to have any attorneys represent them and other rules that simplify the lawsuit process,
    making the whole thing much cheaper, faster,
    and easier. Once each item on the list of services is defined, select all of the individual items for that list, click the Home tab on the
    ribbon and choose Bullets again to turn the bulleted list
    formatting back on for that block of text as shown below:

  28. Casie says:

    This is especially useful if the person you’re inquiring about has a less than common name.

    Not only do you want lots of people to visit your website but you also want your visitors to stay on your site and see if the deal
    is worthwhile by simply checking out your site. The website templates are well-equipped with HTML
    coding which could result into better looking websites in minor budget also.

  29. What a information of un-ambiguity and preserveness of precious know-how about unpredicted emotions.

  30. fenetre alu says:

    I like looking through an article that will make men and women think.
    Also, many thanks for permitting me to comment!

  31. One thing that you necessary to remember almost virtual private server hosting is that it actually is
    source from single powerful hosting server and physical database.
    In general, you can expect to pay $ 50-10 per month, shared web hosting services.
    Your content and applications are placed on a server which is shared with other customers who also use that web host.
    For instance, a website selling adult materials
    could be hosted on the same server as a business selling children’s toys.
    One must bear in mind that a shared hosting plan utilizes all the CPU time, memory and disk space.

    Mentioned briefly already, shared hosting is a popular choice for
    many, especially those on a very tight budget. As technology progresses, so is
    the way how people makes transactions and do business.
    Through the phrase Virtual committed server Internet site
    hosting it is often obvious which the solitary actual hosting server is
    basically cut straight into a number of Virtual Private Servers after which accessible to consumers
    using tiny amount of info exchange, Memory as properly as disk space.
    1, the precise Microsoft and also Milliseconds ASP.
    If you are starting a new website or a web based product then this hosting package would be most preferred to you because it costs the lowest.

  32. I couldn’t resist commenting. Well written!

  33. Micheline says:

    If you are interested in topic: earn to die online games 2013 – you should read about Bucksflooder

1 Pings/Trackbacks for "Client vs. server rendering: are you still using ASP, MVC, JSP, or other?"
  1. […] Click this link immediately, and you’ll see wonderful things! Sensei has said many times that simple is better, and rgubarenko of MakeItSoft has a brand spanking new template engine that is so simple it makes you speechless.  His premise:  every possible rendering task can be accomplished as a random combination of two functional primitives: […]

Leave a Reply

Your email address will not be published. Required fields are marked *


Two (yes, only 2) tiny JavaScript funcs replace the entire ASP, PHP, JSP, or whatever back-end page!

jsRazor in action: recreate AngularJS demos using jsRazor to show the difference.


dummy – insert products splash