it’s just started… the only ‘alpha ready’ and ‘not waste’ resource here is probably https://github.com/evereq/programming/wiki/JavaScript%20&%20jQuerywith list of very useful or at least “required to know about” JavaScript frameworks, libs, jQuery plugins etc…

Hope will have more time to add here the rest of things I am aware about (if it’s possible at all)

jquery-1.7.1.min.js
json2.min.js
modernizr-2.5.3.js
underscore.min.js
backbone.min.js
chosen.jquery.min.js
bootstrap.min.js
...
my.min.js


I specially list names in particular order above, because IT IS important to load some libs in specific order in Web page, e.g.: Chosen jQuery plugin should be loaded AFTER jQuery framework, Backbone.JS framework should be loaded AFTER Underscore.JS (it have hard dependency on it) etc.

However, default order in ASP.NET MVC 4 for loading JS resources might be different from what you want: DefaultBundleOrderer by default load underscore.min.js AFTER backbone.min.js (just because of alphabet ordering) and so on. More so (and it’s a bit separate issue), in the current bootstrap builder exists well know issue with “final semicolons in JS files” (see for example https://github.com/twitter/bootstrap/issues/1758 and https://github.com/twitter/bootstrap/issues/1795 etc.) and so if you use it to get bootstrap.min.js and load something AFTER (in my list above it’s my.min.js file) you will get cool JS exception in browser: “Uncaught TypeError: undefined is not a function” etc.

And so you may want to load files in following order before bootstrap team fix issue (or sure you can fix it easy yourself), i.e. with bootstrap.min.js going LAST in the sequence:

jquery-1.7.1.min.js
json2.min.js
modernizr-2.5.3.js
underscore.min.js
backbone.min.js
chosen.jquery.min.js
...
my.min.js
...
bootstrap.min.js


So how is it possible to change Bundler order? It turns out that it’s easy enough: just use own Orderer, which do basically nothing:

public class AsIsBundleOrderer : IBundleOrderer
{
public virtual IEnumerable<FileInfo> OrderFiles(BundleContext context, IEnumerable<FileInfo> files)
{
if (context == null)
throw new ArgumentNullException("context");

if (files == null)
throw new ArgumentNullException("files");

return files;
}
}

and make sure your Bundle use it instead of DefaultBundleOrderer like this:

protected void Application_Start()
{
...
var bundle = new Bundle("~/Scripts/js", new JsMinify());
bundle.Orderer = new AsIsBundleOrderer();
bundle.AddFile("~/Scripts/jquery-1.7.1.min.js");
bundle.AddFile("~/Scripts/jquery.validate.min.js");
bundle.AddFile("~/Scripts/json2.min.js");
bundle.AddFile("~/Scripts/modernizr-2.5.3.js");
bundle.AddFile("~/Scripts/underscore.min.js");
bundle.AddFile("~/Scripts/backbone.min.js");
bundle.AddFile("~/Scripts/chosen.jquery.min.js");
bundle.AddFile("~/Scripts/my.min.js");
bundle.AddFile("~/Scripts/bootstrap.min.js");
BundleTable.Bundles.Add(bundle);
...
}

Happy end

For example you have complex page which should provide customer with INSERT something, VIEW something or EDIT something features. Naturally you might want to create 3 different templates (let’s say for our example that functionality is completely different for insert, view or edit features and you can’t reuse same template because of that). You don’t want to render all templates when your page loads, do you? .

Unfortunately, currently KnockoutJS documentation don’t have such examples (while show good examples how use “if binding” at http://knockoutjs.com/documentation/if-binding.html, it does not show how to use it with templates).
So I create such example for you (and me): http://jsfiddle.net/evereq/LsaHz

Hope it helps.

Could not load type ‘System.ServiceModel.Activation.HttpModule’ from assembly ‘System.ServiceModel, Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089′.

Easy to fix using following command (run as administrator):
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\aspnet_regiis.exe -iru

Done

P.S. if for some strange reason you still use 32 bit Windows, you should update framework path in command above.

HTTP Error 403.14 – Forbidden
The Web server is configured to not list the contents of this directory.

Hm… EASY to fix with following command (run command prompt as administrator!):
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\aspnet_regiis.exe -i

Done

P.S. if for some strange reason you still use 32 bit Windows, you should update framework path in command above.

High-Memory Quadruple Extra Large Cache Node (cache.m2.4xlarge): 68 GB memory, 26 ECUs (8 virtual cores with 3.25 ECUs each), 64-bit platform, High I/O Capacity cost 2.24$ per hour or about 1600$ per month!

For about 5000-6000$ you can purchase server with following hardware:
4x AMD Opteron 6128 / 2,00GHz Eight-Core (i.e. 32 CORES)
64GB ECC registered DDR3
2 * 80GB 2,5 Intel SSD with Adaptec RAID
1+1 1400W redundant (Hot-Swap) PSU
etc.

Now install here your favorite free Linux and Memcached and you are ready to go

Totally:

Server with better hardware (32 real 2GHz cores instead of 26 ECUs i.e. 8 virtual cores in AMZ, very fast DDR3 memory, redundant power supply and brand MB (Supermicro) instead of “well know instance lifetime issues in AMZ” etc) will cost you something like 3-4 month of AMZ instance rent! Sure, you can say like: what about Collocation cost? Hm… 1U server probably MAX 100$ per month (including some big traffic) etc.

Instead of Conclusion:

So you still think same about Amazon ElasticCache ???

Most probably you already store your virtual disks not in the system drive (i.e. not in drive ‘C’ for example), which is right approach (for performance and other considerations)

However not everybody know that in the C:\ProgramData\Microsoft\Windows\Hyper-V\Virtual Machines folder, Hyper-V actually store huge files (*.bin) for each virtual machine that you run on your Hyper-V host! That may be huge issue in case, if you have a lot of virtual machines in use and your system drive space limited. In addition, it also may introduce fragmentation problems, due to the fact that such files maybe created and removed each time you run your instance or when you create some snapshots etc.

So basically there are 2 main questions you may ask:
a) Why such files (*.bin) are created? And why they are so big? You may notice that size of such files actually equal to amount of virtual memory which you allocate for the virtual instance. So answer is simple – it just a place (such file) to store memory dump for Virtual Machine (instance) and required by Hyper-V
b) Can I get rid of such files? Answer – no In current version of Hyper-V it is not possible. However it is completely possible to move such huge files to separate disk(s) out from system disk! That SHOULD be done I think in any Hyper-V host anyway, in case if you have additional disks here. It is very easy to do that: on the first step of Wizard to create Virtual Machine, do not forget to change location for virtual machine from default one to location, where you have enough space to store both virtual machine memory dump and possible snapshots (in case if you plan to use them sure thing).

My current PC is Intel Q8200 4 Cores / 8Gb memory / SSD Intel 80Gb etc – you get idea

Main difference between my code and Ayende code (as well as many blog comments code) is that I create objects using multiple threads. What is interesting for me that most of people even today, just forget the fact that they have multiple cores in PC (or Server) and modern development should be done with that “stick” idea in your mind: “multitask / multithreading / async may be used if you want to utilize optimally your hardware”. Sure it’s not always make sense to go that “hard way” – some tasks just not scale too much with that approach. At the same time, in that specific tests I was able to get about 50% performance gain using very simple threading model compared to the single threaded. Not bad enough, right?

Sure it’s not really optimal strategy (more optimal for sure to just use C / C++) and I think memory speed restrict CPU power in that specific tests (i.e. no matter how many cores you use in CPU, if your memory / memory controller just can’t get / process all that in the parallel).  In addition I also initialize each created object integer field with some value to restrict some possible optimizations in CLI.  You can also found multiple small optimizations to avoid some overhead etc. Sure it’s not best code out there, but effective enough to demonstrate how TPL can improve results even in such a simple task. Maybe later will found time and write same using C++ with Parallel Patterns Library (PPL) to measure the difference

On my PC test create 4 new threads and each thread create multiple objects. Note that test works 10 seconds to give you more precise results

Tests results: around 150M created and initialized objects per second (don’t forget to build in Release mode if you really want to run it)
I promise to publish new results when new PC arrive to our office;-)

Btw, if you get your own results, will be glad to see and compare

Stay tuned

P.S. Code is not finally optimized and is not “production ready”. Means that I just want to play a bit with what Ayende originally wrote…
For example, you probably may note that test will take longer than 10 seconds to run if your PC already busy with some tasks (simply because I use too much threads for such environment) etc.

P.P.S. No warranties Please do not run that code on your production servers

Update #1: My colleague have notebook with Intel i5 CPU (4 Cores) and he just get  215M result

Update #2: Just get new PC with CPU Intel i7-2600K (at 3.5Ghz) / 8Gb DDR3 1600Mhz memory etc. I get just amazing result: 700M with same source code WOW!

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
using System.Timers;

namespace Testing
{
    class Program
    {
        static volatile bool _isContinue = true;

        static long _total;

        const int TestTimeSec = 10000;

        static Stopwatch _sp;

        static void Main(string[] args)
        {

            var tasks = new List<Task>();

            int processors = Environment.ProcessorCount;

            Console.WriteLine("Detected {0} cores", processors);

            var timer = new System.Timers.Timer(TestTimeSec);
            timer.Elapsed += TimerElapsed;
            timer.AutoReset = false;
            timer.Start();

            _sp = Stopwatch.StartNew();

            for (int t = 0; t < processors; t++)
            {
                tasks.Add(Task.Factory.StartNew(
                    () =>
                    {
                        long i = 0;

                        while (_isContinue)
                        {
                            var obj = new MyClass();
                            i++;
                            obj.B = i;
                        }

                        Interlocked.Add(ref _total, i);
                    }
                ));
            }

            // let's complete all the tasks to get results into _total
            Task.WaitAll(tasks.ToArray());

            _sp.Stop();

            Console.WriteLine("Created {0} objects in {1}", _total / 10, _sp.Elapsed.TotalMilliseconds / 10);
            Console.ReadKey();

        }

        static void TimerElapsed(object sender, ElapsedEventArgs e)
        {
            _isContinue = false;
            Console.WriteLine("Stopping...");
        }

        public class MyClass
        {
            public string A;
            public long B;
            public DateTime C;
        }

    }
}

a) Rough ETA x 4

OR

b) Periodical updates of ETA

I found both make sense to use together, so I recommend something like this:

1. Initially Estimate Rough ETA x2 or x 4 (depends how you feel yourself confident with given issue), with precision to hour / day (round value up).
   Forget minutes precision in all cases, forget hour precision in many cases. If you feel that issue takes 2 minutes to fix – put estimation 0. If you feel that it’s more like 15 minutes – put estimation 1 hour. If you feel it’s like 3-4 hours, put estimation 1 day. Don’t try to be precise. Instead it should be realistic.
   For example you think it takes 20 minutes to fix issue but you don’t have previous experience with such issues, so you got 20×4 = 80 minutes and round it up to 2 hours. Put value 2 hours into issues tracking software.  If your software support ranges, put here 20 – 80 minutes range.
2. If you use estimation precision as hour, you should update your estimation at least every hour, if you see that now you can measure ETA better.  If you use precision day, update your estimation at least ones per day. As more frequently you update your estimation as better. Sure don’t be too paranoiac - update previous estimation only if it changes significantly.
   For example say you estimate issue initially to 2 hours, so after first hour you working on issue, compare your initial estimation (2 hours) with what you think you have now (don’t forget about ETA x 4), for example now you feel that you need another 35 minutes to fix, so you multiple 35 * 4 and got 140 minutes = 3 hours. So you adjust your initial estimation from 2 hours to 4 hours (1 hour you already spend plus 3 hours you think it will take more).

Advantages:

1. You update your estimations frequently so even if you made serious mistake in estimation before, you quickly resolve. Fail quickly Your colleges and boss know where you are, so excellent transparency and you agile
2. You don’t care if you need to go to made coffee, go to rest for a while etc. You made your estimation SAFE enough (x2 or x4!) and you know that in next hour (or day if bug is complex) you always may update estimation again with more precise value.

In contrast to approach above, it can better in some cases (in most of cases in my experience)  to use “relative” measurement instead of time measurement.  Unfortunately in reality, seems it’s a bit more hard to begin with in some less agile teams. Another issue is that it’s just not every issues / bug tracking software support that.  In that alternative approach you think how much more complicated given issue is, compared to other issues you have / you done before and made your estimations relative.

P.S. Many people don’t like x4. Sure it’s completely optional. I saw people (and I am one of them ) that can do exact estimations in most of cases: in some cases because of luck, in other cases because of experience. In different cases because of both. Maybe it’s because usually they (and me) do that calculation x2-x4 in the mind and do not do it formally.
Taking to attention fact that it’s impossible to work 9-12 hours per day with same focus (hope my boss don’t read that Joke), it’s best way to always remember that effectively you have about 4-5-6 hours “crazy” time per day when you really can do your job with high focus and with maximum performance, while other time is required to prepare yourself for that “fight / micro-sprint”. So at least x2 should be applied in most of cases to be safe and I recommend to do it in your mind so your colleges get only one final estimation value, not intermediate result. It’s not about transparency. It’s more about ‘useless information’ for everyone, how exactly you calculate your estimations. Everybody may value you only by how your real time to fix issue was different to what you estimate.  And in most cases if that is not important! But what is true is that nobody care how you calculate ETA after you made your job done. People trust you because of results of your work, not because you do nice calculations, but it takes you 10x times more to fix issue than you think initially.

Just keep it simple, as always