docs: def check_naming_conventions(self, ds):
          '''
          Checks the variable names to ensure they are valid CF variable names under CF.
  
          CF §2.3 Variable, dimension and attribute names should begin with a letter
          and be composed of letters, digits, and underscores.
  
          :param netCDF4.Dataset ds: An open netCDF dataset
          :rtype: compliance_checker.base.Result
          '''
          ret_val = []
          variable_naming  = TestCtx(BaseCheck.MEDIUM, self.section_titles['2.3'])
          dimension_naming = TestCtx(BaseCheck.MEDIUM, self.section_titles['2.3'])
          attribute_naming = TestCtx(BaseCheck.MEDIUM, self.section_titles['2.3'])
  
          ignore_attributes = [
              '_FillValue',
              'DODS',
              '_ChunkSizes',
              '_Coordinate',
              '_Unsigned'
          ]
  
          rname = regex.compile("^[A-Za-z][A-Za-z0-9_]*$")
  
          for name, variable in ds.variables.items():
              variable_naming.assert_true(rname.match(name) is not None,
                                          "variable {} should begin with a letter and be composed of "
                                          "letters, digits, and underscores".format(name))
  
              # Keep track of all the attributes, we'll need to check them
              for attr in variable.ncattrs():
                  if attr in ignore_attributes:
                      continue
                  # Special attributes made by THREDDS
                  if attr.startswith('DODS'):
                      continue
                  # Ignore model produced attributes
                  if attr.startswith('_Coordinate'):
                      continue
                  attribute_naming.assert_true(rname.match(attr) is not None,
                                               "attribute {}:{} should begin with a letter and be composed of "
                                               "letters, digits, and underscores".format(name, attr))
  
          ret_val.append(variable_naming.to_result())
  
          for dimension in ds.dimensions:
              dimension_naming.assert_true(rname.match(dimension) is not None,
                                           "dimension {} should begin with a latter and be composed of "
                                           "letters, digits, and underscores".format(dimension))
          ret_val.append(dimension_naming.to_result())
  
          for global_attr in ds.ncattrs():
              if global_attr.startswith('DODS'):
                  continue
              attribute_naming.assert_true(rname.match(global_attr) is not None,
                                           "global attribute {} should begin with a letter and be composed of "
                                           "letters, digits, and underscores".format(global_attr))
          ret_val.append(attribute_naming.to_result())
  
          return ret_val