title: Perfomance issues with large number of elements in Mithril.js
body: <p>My app has a sort- and filterable list and a few inputs and checkboxes so far.
  The problem appears if the list has more than 500 items, then every every element with user input (checkboxes, input fields, menus) start to have a lag around half a second increasing with the number of items in the list. The sorting and filtering of the list is done fast enough but the lag on the input elements is too long. </p>
  
  <p>The question is: how can the list and the input elements be decoupled?</p>
  
  <p>Here is the list code:</p>
  
  <pre><code>var list = {}
  list.controller = function(args) {
      var model = args.model;
      var vm = args.vm;
      var vmc = args.vmc;
      var appCtrl = args.appCtrl;
  
      this.items = vm.filteredList;
      this.onContextMenu = vmc.onContextMenu;
  
      this.isSelected = function(guid) {
          return utils.getState(vm.listState, guid, "isSelected");
      }
      this.setSelected = function(guid) {
          utils.setState(vm.listState, guid, "isSelected", true);
      }
      this.toggleSelected = function(guid) {
          utils.toggleState(vm.listState, guid, "isSelected");
      }
      this.selectAll = function() {
          utils.setStateBatch(vm.listState, "GUID", "isSelected", true, this.items());
      }.bind(this);
      this.deselectAll = function() {
          utils.setStateBatch(vm.listState, "GUID", "isSelected", false, this.items());
      }.bind(this);
      this.invertSelection = function() {
          utils.toggleStateBatch(vm.listState, "GUID", "isSelected", this.items());
      }.bind(this);
  
      this.id = "201505062224";
      this.contextMenuId = "201505062225";
  
      this.initRow = function(item, idx) {
          if (item.online) {
              return {
                  id : item.guid,
                  filePath : (item.FilePath + item.FileName).replace(/\\/g, "\\\\"),
                  class : idx % 2 !== 0 ? "online odd" : "online even",
              }
          } else {
              return {
                  class : idx % 2 !== 0 ? "odd" : "even"
              }
          }
      };
  
      // sort helper function
      this.sorts = function(list) {
          return {
              onclick : function(e) {
                  var prop = e.target.getAttribute("data-sort-by")
                  //console.log("100")
                  if (prop) {
                      var first = list[0]
                      if(prop === "selection") {
                          list.sort(function(a, b) { 
                              return this.isSelected(b.GUID) - this.isSelected(a.GUID)
                          }.bind(this)); 
                      } else {
                          list.sort(function(a, b) {
                              return a[prop] &gt; b[prop] ? 1 : a[prop] &lt; b[prop] ? -1 : 0
                          })
                      } 
                      if (first === list[0])
                          list.reverse()
                  }
              }.bind(this)
          }
      }; 
  
      // text inside the table can be selected with the mouse and will be stored for
      // later retrieval
      this.getSelected = function() {
          //console.log(utils.getSelText());
          vmc.lastSelectedText(utils.getSelText());
      };
  };
  
  list.view = function(ctrl) {
  
      var contextMenuSelection = m("div", {
          id : ctrl.contextMenuId,
          class : "hide"
      }, [
      m(".menu-item.allow-hover", {
          onclick : ctrl.selectAll
      }, "Select all"),
      m(".menu-item.allow-hover", {
          onclick : ctrl.deselectAll
      }, "Deselect all"), 
      m(".menu-item.allow-hover", {
          onclick : ctrl.invertSelection
      }, "Invert selection") ]);
  
      var table = m("table", ctrl.sorts(ctrl.items()), [
      m("tr", [
              m("th[data-sort-by=selection]", {
                   oncontextmenu : ctrl.onContextMenu(ctrl.contextMenuId, "context-menu context-menu-bkg", "hide" )
               }, "S"),
              m("th[data-sort-by=FileName]", "Name"),
              m("th[data-sort-by=FileSize]", "Size"), 
              m("th[data-sort-by=FilePath]", "Path"), 
              m("th[data-sort-by=MediumName]", "Media") ]), 
      ctrl.items().map(function(item, idx) {
          return m("tr", ctrl.initRow(item, idx), {
              key : item.GUID
          },
          [ m("td", [m("input[type=checkbox]", {
              id : item.GUID,
              checked : ctrl.isSelected(item.GUID),
              onclick : function(e) {ctrl.toggleSelected(this.id);}
          }) ]),
          m("td", {
              onmouseup: function(e) {ctrl.getSelected();}
              }, item.FileName), 
          m("td", utils.numberWithDots(item.FileSize)), 
          m("td", item.FilePath), 
          m("td", item.MediumName) ])
      }) ])
  
      return m("div", [contextMenuSelection, table])
  }
  </code></pre>
  
  <p>And this is how the list and all other components are initialized from the apps main view:</p>
  
  <pre><code>// the main view which assembles all components
  var mainCompView = function(ctrl, args) {
      // TODO do we really need him there?
      // add the main controller for this page to the arguments for all
      // added components
      var myArgs = args;
      myArgs.appCtrl = ctrl;
  
      // create all needed components
      var filterComp = m.component(filter, myArgs);
      var part_filter = m(".row", [ m(".col-md-2", [ filterComp ]) ]);
  
      var listComp = m.component(list, myArgs);
      var part_list = m(".col-md-10", [ listComp ]);
  
      var optionsComp = m.component(options, myArgs);
      var part_options = m(".col-md-10", [ optionsComp ]);
  
      var menuComp = m.component(menu, myArgs);
      var part_menu = m(".menu-0", [ menuComp ]);
  
      var outputComp = m.component(output, myArgs);
      var part_output = m(".col-md-10", [ outputComp ]);
  
      var part1 = m("[id='1']", {
          class : 'optionsContainer'
      }, "", [ part_options ]);
  
      var part2 = m("[id='2']", {
          class : 'menuContainer'
      }, "", [ part_menu ]);
  
      var part3 = m("[id='3']", {
          class : 'commandContainer'
      }, "", [ part_filter ]);
  
      var part4 = m("[id='4']", {
          class : 'outputContainer'
      }, "", [ part_output ]);
  
      var part5 = m("[id='5']", {
          class : 'listContainer'
      }, "", [ part_list ]);
  
      return [ part1, part2, part3, part4, part5 ];
  }
  
  // run
  m.mount(document.body, m.component({
      controller : MainCompCtrl,
      view : mainCompView
  }, {
      model : modelMain,
      vm : modelMain.getVM(),
      vmc : viewModelCommon
  }));
  </code></pre>
  
  <p>I started to workaround the problem by adding m.redraw.strategy("none") and  m.startComputation/endComputation to click events and this solves the problem but is this the right solution? As an example, if I use a Mithril component from a 3rd party together with my list component, how should I do this for the foreign component without changing its code?</p>
  
  <p>On the other side, could my list component use something like the 'retain' flag? So the list doesn't redraw by default unless it's told to do?  But also the problem with a 3rd party component would persist.</p>
  
  <p>I know there are other strategies to solve this problem like pagination for the list but I would like to know what are best practices from the Mithril side.</p>
  
  <p>Thanks in advance,
  Stefan</p>