Table of Contents

MonkeyProof MATLAB Coding Standard

Table of Contents

Introduction

• Naming conventions

  • Loop iterator naming
  • Negated boolean names
  • Parent / child name redundancy
  • Name shadowing
  • Names to avoid
  • Function names document their use
  • Function name construction
  • Name-value pair casing
  • The 'Test' suffix
  • Name length
  • Descriptive names
  • The 'is' prefix
  • Abbreviations
  • Units in variable names
  • The 'n' prefix
  • Name class object

• Layout & comments

  • Comment blocks
  • Function indentation
  • Whitespace in statements
  • Whitespace after characters
  • Line length
  • Indentation length
  • Comments on poorly written code
  • Equals sign alignment
  • Commas in rows
  • Methods/Properties blocks with duplicate attributes
  • Whitespace at the end of a line
  • Tab characters
  • Properties blocks before methods blocks
  • Help text
  • Whitespace around blocks of code
  • Correct spelling
  • Align struct definition
  • Constants with end of line comments

• Statements & expressions

  • Constant definitions at top
  • Magic numbers
  • Function calls without inputs
  • One statement per line
  • If else
  • Switch otherwise
  • Mixed types in expressions
  • Parentheses in logical expressions
  • Parentheses in mathematical expressions
  • Assert inputs
  • Global variables
  • Constant conditional statements
  • Group struct field definitions
  • Dependencies known
  • Try for exception handling
  • Floating-point comparisons
  • Zero before decimal point
  • Workspace variable ans
  • Debugging functions
  • Elseif else
  • Abstract class instantiation
  • Command syntax
  • Accessing other workspaces
  • Logical indexing
  • Loop vectorization
  • Use switch blocks
  • Variable in one unit
  • Undocumented functions

• Higher level rules

  • Complexity
  • Number of function arguments
  • Constructors with single output
  • Scripts
  • Editor warnings
  • Getters and setters
  • Mex-files
  • Nesting depth
  • Repeated code
  • Structure ownership
  • Single responsibility
  • Commented out code
  • Reuse of iterator variables
  • Rewriting existing functions
  • Columns with implicit meaning
  • Nested functions
  • Input parameter dependency
  • Missing methods declarations and implementations
  • Mismatch input and output declarations and implementations
  • First output constructor
  • Iterator variables outside loop
  • More input arguments than expected
  • Superclass property implementation
  • Java dependency
  • Method access permissions

• Security

  • Eval-functions
  • Shell escape
  • Security Security Server Certificate Usage
  • Security XML reading
  • Constant variable names
  • Security Username and Password

• Release notes

Introduction

The goal of this standard that can be automatically checked is to help you write consistent, clean, understandable and maintainable m-code. The resulting code will be more readable for both yourself and others. These rules are no strict rules that must be followed at all cost. They are simply there to help you write m-code well and you can deviate from them as you please.

Automatic compliance checking

Most of the rules described here can be checked using CC4M by MonkeyProof Solutions. The checkable rules are indicated by this logo at the top. These rules are configured in the predefined MonkeyProofMATLABCodingStandard configurations set available with the tool. For instructions on how to check your code against a coding standard, see the video below. The steps are also described below the video.

You can check your code for compliance with the rules described here as follows:

1. Install CC4M. If you have not purchased the tool yet, you can do so here. Alternatively, you could request a free trial license there.
2. Open CC4M in one of two ways:
   • Click the shortcut created at the top of the screen next to the documentation search bar: .
   • Run monkeyproof.cc4m.start() from the command window.
3. Select whether you want to check one or more files, all files in a folder, or all files in a MATLAB Project.
4. Select what files/folder/project to check.
5. Further customization is available, for example checking a folder including or excluding all subfolders.
6. Click the Run button at the bottom to start checking your code.

Realization

This coding standard has been constructed in consultation with multiple large companies that are using MATLAB on a daily basis. With years of experience in the industry, they are able to provide invaluable input on what MATLAB-related coding rules to follow and why.

With the help of -among others- Paul Jansen of TIOBE, we have been able to come to a coding standard that reflects the needs and wishes of professional teams trying to write clean and reliable MATLAB code that is easy to read and maintain.

Structure of this document

The rules are grouped under specific categories to help keep things organized:

• Naming conventions: Rules in this chapter describe how variables, functions etc. can be named in a consistent and insightful manner.
• Layout & comments: This chapter contains rules to help improve readability of your code for yourself and for others. There are rules on whitespace, comments and more.
• Statements & expressions: The rules in this chapter are about how to use constructs such as if/else blocks, what built-in functions or keywords to avoid, how to best structure your statements etc.
• Higher level rules: This chapter contains (among others) rules on higher-level objects such as functions or files.
• Security: This chapter contains rules on potential security risks.

Rule template

Every rule is structured as follows:

Rule name

Avoid:

One or more code examples to avoid using.

Instead use:

The example(s) above improved by complying with the rule.

Severity levels

The following definition of the severity levels is used as a guide to make it easier to group the different rules and coding standards.

• Level 1 - Certainly a programming error
• Level 2 - Very likely a programming error
• Level 3 - Programming pitfall/undesired programming construct/accident waiting to happen
• Level 4 - Design issue with high impact on reliability or maintainability
• Level 5 - Design issue with low impact on reliability or maintainability
• Level 6 - Portability or performance issue or high impact other issue
• Level 7 - Comment related issue or medium impact other issue
• Level 8 - Naming convention or low impact other issue
• Level 9 - Style related issue
• Level 10 - Controversial issue or issue with a relatively high false positive rate

Each rule in this coding standard has a severity level attached to it. These severity levels are set in the CC4M and one can configure for which severity levels to check. The severity levels are related to the severity levels of Tiobe's TICS tooling.

Naming conventions

The rules in this chapter describe how variables, functions etc. can be named in a consistent and insightful manner.

Loop iterator naming

Avoid:

for nodeIdx = 1 : 10
    for j = 1 : 3
        myGraph(nodeIdx).plotIt(j);
    end
end

Instead use:

for iNode = 1 : 10
    for jPoint = 1 : 3
        myGraph(iNode).plotIt(jPoint);
    end
end

Negated boolean names

Avoid:

if ~notValid && isNotFound
    error('My error message.')
end

Instead use:

if isValid && ~isFound
    error('My error message.')
end

Parent / child name redundancy

Avoid:

Beam.beamThickness
chair.weightOfChair

Instead use:

Beam.thickness
chair.weight

Name shadowing

Names to avoid

Function names document their use

Function name construction

Name-value pair casing

Avoid:

function plotMeasurement(options)

arguments
    options.number_of_lines             = 3
    options.precision                   = 2.5
    options.SHOW_LEGEND (1, 1) logical  = true
end

...

end

Instead use:

function plotMeasurement(options)

arguments
    options.NumberOfLines               = 3
    options.Precision                   = 2.5
    options.ShowLegend (1, 1) logical   = true
end

...

end

The 'test' suffix

Name length

Avoid:

maximumValueOfTheEntireSetOfDataPoints = max(data);

Instead use:

maxData = max(data);

Descriptive names

Avoid:

function tk = convC2k(temp)

Instead use:

function temperatureK = convertCelsiusToKelvin(temperatureC)

The 'is' prefix

Abbreviations

Avoid:

arrTim

Instead use:

arrivalTime

Units in variable names

Avoid:

accelerationInMillimetersPerSecondSquared = 1000;

Instead use:

acceleration = 1000; % [mm/s^2]

The 'n' prefix

Avoid:

numberOfFiles
nrCars
lineCount

Instead use:

nFiles
nCars
nLines

Name class object

Avoid:

classdef CarAnalyzer
	methods
		function velocity = initialVelocity(theCar)
			velocity = theCar.velocity;
		end
		
		
		function position = initialPosition(theVehicle)
			position = theVehicle.position;
		end
	end
end

Instead use:

classdef CarAnalyzer
	methods
		function velocity = initialVelocity(theCar)
			velocity = theCar.velocity;
		end
		
		
		function position = initialPosition(theCar)
			position = theCar.position;
		end
	end
end

Layout & comments

This chapter contains rules to help improve readability of your code for yourself and for others. The rules on indentation and whitespace make the code more visually appealing whereas rules on comments increase the usability of the code they reference. By using ample whitespace, your code will look clean and the more complicated statements maintain their readability.

Comment blocks

Avoid:

%{ This is a comment.
This is also a comment.
%}

Instead use:

% This is a comment.
% This is also a comment.

Function indentation

Avoid:

function computeWeight(in)
weight = 2 * in;
end

Instead use:

function computeWeight(in)
    weight = 2 * in;
end

Whitespace in statements

Avoid:

isValid=y>0&&x==-1;

Instead use:

isValid = y > 0 && x == -1;

Whitespace after characters

Avoid:

while(ismember(x, [3,5,7,11,13]))
    x = x + 2;
end

Instead use:

while ismember(x, [3, 5, 7, 11, 13])
    x = x + 2;
end

Line length

Avoid:

theText = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut luctus arcu ex, at viverra nibh malesuada ac. Proin vel arcu leo.';

Instead use:

theText = ['Lorem ipsum dolor sit amet, consectetur adipiscing elit. ', ...
            'Ut luctus arcu ex, at viverra nibh malesuada ac. Proin vel arcu leo.'];

Indentation length

Avoid:

if x > 0
  if x < 2
    disp(x)
  end
end

Instead use:

if x > 0
    if x < 2
        disp(x)
    end
end

Comments on poorly written code

Avoid:

x = 2;
y = 3 * x; % TODO: take z into account.

% FIXME: This piece of ugly code is copied from StackExchange.
z=[1,23,8.1]*(x^3.1415)*sqrt(y);

Instead use:

x = 2;
y = 3 * x + z; 

z = [1, 23, 8.1] * (x ^ 3.1415) * sqrt(y);

Equals sign alignment

Avoid:

carWeight = 1.7 * 600;
nWheels = 2 + 2;
maximumSpeed = 190;

Instead use:

carWeight       = 1.7 * 600;
nWheels         = 2 + 2;
maximumSpeed    = 190;

Commas in rows

Avoid:

fig.Position    = [0 1000 1.5 130];
saying          = ['An apple a ' period ' keeps the doctor away.'];

Instead use:

fig.Position    = [0, 1000, 1.5, 130];
saying          = ['An apple a ', period, ' keeps the doctor away.'];

Methods/Properties blocks with duplicate attributes

Avoid:

classdef Rocket
    properties (Access = public, Hidden = false, Constant)
        Fuel = "Nuclear"
    end
    
    properties (Constant = true)
        Capacity = 2
    end
end

Instead use:

classdef Rocket
    properties (Constant)
        Fuel = "Nuclear"
        Capacity = 2
    end
end

Whitespace in statements

Tab characters

Properties blocks before methods blocks

Help text

Avoid:

function [avg, maxSize] = measureSize(obj, dim)
avg = mean(obj.Size, dim);
maxSize = max(obj.Size, dim);
end

Instead use:

function [avg, maxSize] = measureSize(obj, dim)
%MEASURESIZE Computes the size of the Item object.
%
% Input:
%   obj         The Item object.
%   dim         Dimension to measure.
%
% Output:
%   avg         Average size of the item.
%   maxSize     Maximum size of the item.

avg     = mean(obj.Size, dim);
maxSize = max(obj.Size, dim);
end

Whitespace around blocks of code

Avoid:

deltaX          = mean(xIn);
xOut            = xIn - deltaX;
scalingFactor   = newZ / currentZ;
xOut            = xOut .* scalingFactor;
xOut            = xOut + deltaX;

Instead use:

% Shift to origin.
deltaX  = mean(xIn);
xOut    = xIn - deltaX;

% Calculate scaling.
scalingFactor   = newZ / currentZ;
xOut            = xOut .* scalingFactor;

% Shift back.
xOut = xOut + deltaX;

Correct spelling

Avoid:

% get sclaing factor
scaling_factor = new_z / current_z;
x_out = x_out * scaling_factor; % now recslaed

Instead use:

% Get the scaling factor.
scalingFactor = newZ / currentZ;
xOut = xOut * scalingFactor; % Now rescaled.

Align struct definition

Avoid:

s = struct("name", "Albert", "age", 2021 - 1979, "isValid", ismember("Albert", allNames));

Instead use:

s = struct(...
    "name",     "Albert", ...
    "age",      2021 - 1979, ...
    "isValid",  ismember("Albert", allNames))

Constants with end of line comments

Avoid:

THRESHOLD = 10;

Instead use:

THRESHOLD = 10; % [dB] Max noise level

Statements & expressions

The rules in this chapter are about how to use constructs such as if/else blocks, what built-in functions or keywords to avoid or how to best structure your statements. Following these rules will ensure the individual statements in your code are complete and easy to read.

Constant definitions at top

Avoid:

function testConstants(x)
y = 3 * x;
MAX_Z = 100;
z = min(y, MAX_Z);
end

Instead use:

function testConstants(x)
MAX_Z = 100;

y = 3 * x;
z = min(y, MAX_Z);
end

Magic numbers

Avoid:

for iPick = 1 : 52
    disp(randi(13));
end

Instead use:

DECK_SIZE   = 52;
N_VALUES    = 13;

for iPick = 1 : DECK_SIZE
    disp(randi(N_VALUES));
end

Function calls without inputs

Avoid:

x = rand * 2;

Instead use:

x = rand() * 2;

One statement per line

Avoid:

persistent x, y

for iNode = 1 : 3, x = x + iNode; disp(x); end

Instead use:

persistent x
persistent y 

for iNode = 1 : 3
    x = x + iNode;
    disp(x);
end

If else

Avoid:

if x > 0
    saveData()
end

Instead use:

if x > 0
    saveData()
else
    % Do not save data.
end

Switch otherwise

Avoid:

switch reply
    case "Yes"
        saveData()
    case "No"
        clearData()
end

Instead use:

switch reply
    case "Yes"
        saveData()
    case "No"
        clearData()
    otherwise
        % Should not get here.
        error("Unknown reply " + reply)
end

Mixed types in expressions

Avoid:

d = a * b && c;

Instead use:

d = (a * b > 0) && c;

Parentheses in logical expressions

Avoid:

d = a && b || c;

Instead use:

d = (a && b) || c;

Parentheses in mathematical expressions

Avoid:

d = a * b + c;
h = f / 2 * g;

Instead use:

d = (a * b) + c;
h = (f / 2) * g;

Assert inputs

Avoid:

assert(~isempty(list))

Instead use:

assert(~isempty(list), 'ClassName:MethodName:ListIsEmpty', 'The list shall not be empty.')

Global variables

Constant conditional statements

Avoid:

if x > 0 || true
    disp(x)
end   

Instead use:

disp(x)

Group struct field definitions

Avoid:

s = struct("f", 2, "g", 3);

computeCost(s);
s.h = 'new field';

Instead use:

s = struct("f", 2, "g", 3, "h", 'new field');

computeCost(s);

Dependencies are known

Try for exception handling

Avoid:

try
    nElems = container.nElements;
catch
    nElems = 0;
end

Instead use:

if isfield(container, 'nElements')
    nElems = container.nElements;
else
    nElems = 0;
end

Floating-point comparisons

Avoid:

out = myFcn(in) == sqrt(3);

Instead use:

out = abs(myFcn(in) - sqrt(3)) < 1e-12;

Zero before decimal point

Avoid:

THRESHOLD = .5;

Instead use:

THRESHOLD = 0.5;

Workspace variable ans

Avoid:

function out = get_value(in)
3 + 3;

out = ans + in;

Instead use:

function out = get_value(in)
var1 = 3 + 3;

out = var1 + in;

Debugging functions

Elseif else

Avoid:

if x > 0
    y = 10;
elseif x == 0
    y = 0;
end

Instead use:

if x > 0
    y = 10;
elseif x == 0
    y = 0;
else
    y = -1;
end

Abstract class instantiation

Do not use the command syntax

Avoid:

verifyNameLength namePersonA namePersonB

Instead use:

verifyNameLength("namePersonA", "namePersonB")

Accessing other workspaces

Logical indexing

Avoid:

index = intersect(find(v > MIN), find(v < MAX));

Instead use:

index = (v > MIN) & (v < MAX);

Loop vectorization

Avoid:

dataResult = false(size(dataset));

for iElem = 1 : numel(dataset)
    if dataset(iElem) < limit(iElem)
        dataResult(iElem) = true;
    else
        dataResult(iElem) = false;
    end
end

Instead use:

dataResult = dataset < limit;

Use switch blocks

Avoid:

if name == "Bill"
    ...
elseif ismember(name, ["Judith", "Bob"])
    ...
elseif name == "Steve"
    ...
else
    ...
end

Instead use:

switch name
    case "Bill"
        ...
    case {"Judith", "Bob"}
        ...
    case "Steve"
        ...
    otherwise
        ...
end

Variable in one unit

Avoid:

halfLifeTime = 580; % [s]
halfLifeTime = halfLifeTime / 3600; % [h]

Instead use:

SECONDS_TO_HOURS    = 1 / 3600;
halfLifeTime        = 580; % [s]
halfLifeTime        = halfLifeTime * SECONDS_TO_HOURS; % [h]

Undocumented functions

Higher level rules

The rules in this chapter transcend individual statements. These higher-level rules treat things like code complexity and function types.

Complexity

Number of function arguments

Avoid:

out = computeWeight(blockHeight, blockWidth, blockDepth, density, nBlocks, idx);

Instead use:

out = computeWeight(blockData, nBlocks, idx);

Constructors with single output

Avoid:

classdef Computer
    methods
        function [obj, out2] = Computer(in)
            obj.value = in;
            out2 = 2 * in;
        end
    end
end

Instead use:

classdef Computer
    methods
        function obj = Computer(in)
            obj.value = in;
        end
    end
end

Scripts

Editor warnings

Avoid:

%#ok<*ABCDE> Suppress a Code Analyzer warning in the entire file.

Instead use:

%#ok<ABCDE> Suppress the Code Analyzer warning on this line alone.

Getters and setters

Mex-files

Nesting depth

Repeated code

Ownership structure

Avoid:

function [out] = calculateSpeed(car)

out = car;

% do not remove fields from existing struct
car = rmfield(car, 'speed');

Instead use:

function [out] = calculateSpeed(car)

out = car;

% clear the field
car.speed = [];

Single responsibility

Commented out code

Reuse of iterator variables

Avoid:

for iNode = 1 : numel(nodes)
    ...
end

for iNode = 1 : 2 : 11
    ...
end

Instead use:

for iNode = 1 : numel(nodes)
    ...
end

for iValue = 1 : 2 : 11
    ...
end

Rewriting existing functions

Columns with implicit meaning

Avoid:

% data is a matrix.
density = data(:, 1) ./ (data(:, 2) .* data(:, 3) * data(:, 4));

Instead use:

% data is a table or struct of arrays.
density = data.mass ./ (data.height .* data.width .* data.length);

% Alternatively, with individual vectors.
density = mass ./ (theHeight .* theWidth .* theLength);

Nested functions

Input parameter dependency

Avoid:

function [meanV, meanA] = getMeanVandA(velocities, distances, timePts)
meanV = sum(distances) ./ sum(timePts);
meanA = velocities(end) ./ sum(timePts);
end

function vectorOut = processVector(vectorIn, vectorLength)
for iIdx = 1 : vectorLength
    vectorOut(ii) = processScalar(vectorIn(ii));
end
end

Instead use:

function [meanV, meanA] = getMeanVandA(distances, timePts)
meanV      = sum(distances) ./ sum(timePts);
velocities = distances ./ timePts;
meanA      = velocities(end) ./ sum(timePts);
end

function vectorOut = processVector(vectorIn)
for iIdx = 1 : length(vectorIn)
    vectorOut(ii) = processScalar(vectorIn(ii));
end
end

Missing methods declarations and implementations

Mismatch input and output declarations and implementations

Avoid:

methods(Static)
    out1 = getFolder(in2, in1)	
end

function [reportsFolder, isOk] = getFolder(in1, in2)
....
end

Instead use:

methods(Static)
    [reportsFolder, isOk] = getFolder(in1, in2)	
end

function [reportsFolder, isOk] = getFolder(in1, in2)
....
end

The first output of a constructor should be the object of the class

Avoid:

classdef ConstructorDesign

   properties
      computedValue
   end

	methods
		function x = ConstructorDesign()
			obj.computedValue = 100;
			x                 = 101
		end
		
	end
end

Instead use:

classdef ConstructorDesign

   properties
      computedValue
   end

	methods
		function obj = ConstructorDesign()
			obj.computedValue = 100;
			x                 = 101
		end
		
	end
end

Use of iterator variables outside the for loop

Avoid:

for iNode = 1 : numel(nodes)
    if valueIn(iNode) > threshold
		break;
	end
end

valueOut = iNode + 10;

Instead use:

idx      = 0;

for iNode = 1 : numel(nodes)
    ...
	
	if valueIn(iNode) > threshold
		idx      = iNode;
		break
	end
end

valueOut = idx + 10;

More input arguments than expected

Avoid:

function processTemperatures(Tin1, Tin2, Tin3)
	x = calculateMaxTemperature(Tin1, Tin2, Tin3);
end

function out = calculateMaxTemperature(Tin1, Tin2)
	out = max(Tin1, Tin2);
end

Instead use:

function processTemperatures(Tin1, Tin2, Tin3)
	x = calculateMaxTemperature(Tin1, Tin2);
end

function out = calculateMaxTemperature(Tin1, Tin2)
	out = max(Tin1, Tin2);
end

Superclass property implementation

Avoid:

classdef Measurement
    properties
        measurementDate
    end
end

classdef Pressure < Measurement
    properties
        measurementDate = today()
    end
end

Instead use:

classdef Measurement
    properties
        measurementDate
    end
end

classdef Pressure < Measurement
    methods
        function obj = Pressure()
            obj.measurementDate = today();
        end
    end
end

Avoid Java dependency

Method access permissions

Avoid:

classdef Table
    methods (protected)
        computeMass(obj)
    end
end

classdef Desk < Table
    methods
        function computeMass(obj)
            ...
        end
    end
end

Instead use:

classdef Table
    methods (protected)
        computeMass(obj)
    end
end

classdef Desk < Table
    methods (protected)
        function computeMass(obj)
            ...
        end
    end
end

Security

This chapter contains rules to help avoiding potential security risks.

The topic of (online) security is very broad and solutions can be applied in many gradations of strictness. Therefore, it is recommended to discuss the topic with those familiar with the company policies, to determine which security considerations should be taken into account for your application.

These guidelines help to avoid some common security risks, but are by no means a substitute for a good design and security analysis by a professional.

Eval-functions

Shell escape

Avoid:

!mycommand

Instead use:

system('mycommand')

Security Server Certificate Usage

Avoid:

% During construction
opts = weboptions("CertificateFilename", "");
opts = matlab.net.http.HTTPOptions("CertificateFilename", "");

% Post-construction
opts.CertificateFilename = "";

Instead use:

%% Do not specify "CertificateFilename" at all:

% During construction
opts = weboptions();
opts = matlab.net.http.HTTPOptions();

%% Specify default certificates:

% During construction
opts = weboptions("CertificateFilename", "default");
opts = matlab.net.http.HTTPOptions("CertificateFilename", "default");

% Post-construction
opts.CertificateFilename = "default";

%% Specify a certificate file explicitly:

% During construction
opts = weboptions("CertificateFilename", "MyFile.crt");
opts = matlab.net.http.HTTPOptions("CertificateFilename", "MyFile.crt");

% Post-construction
opts.CertificateFilename = "MyFile.crt";

Security XML reading

Avoid:

content = xmlread(myFile);
p = matlab.io.xml.dom.Parser();
p.Configuration.AllowDoctype = true;
p.parseFile(myFile);

Instead use:

content = xmlread(myFile, "AllowDoctype", false);

% For matlab.io.xml.dom.Parser configurations, AllowDoctype is false by default.
p = matlab.io.xml.dom.Parser();
p.parseFile(myFile);

Constant variable names

Avoid:

username = 'myName';
password = 'myPassword';

Instead use:

% Ask the user to provide a username and password, for example using a dialog:
[username, password] = showLoginDialog();

Note: This is just one example of how to obtain credentials without hardcoding them. Ask your IT department for the available options.

Security Username and Password

Avoid:

import matlab.net.http.Credentials

creds = Credentials('Username', 'John', 'Password', 'secret');
weboptions("Username", "John", "Password", "secret");

Instead use:

import matlab.net.http.Credentials

% Ask the user to provide a username and password, for example using a dialog or prompt:
[username, password] = showLoginDialog();

creds = Credentials('Username', username, 'Password', password);
weboptions("Username", username, "Password", password);

Note: This is just one example of how to obtain credentials without hardcoding them. Ask your IT department for the available options.

Release notes

Release 1.3.0 (May 2023)

Added

• Created a specific chapter for security related rules.
• A rule server certificate usage.
• A rule on not setting the option AllowDoctype to false when reading an XML file.
• A rule on not using constant variable names as username, loginname, password etc.
• A rule on not using hard-coded username and or password.

Changed

• Moved the rule about not using eval-functions from the chapter Statements to Security, so STAT-14 became SECURITY-1.
• Moved the rule about not using the shell escape function from the chapter Statements to Security, so STAT-16 became SECURITY-2.

Release 1.2.0 (October 2022)

Added

• A rule on consistent naming for class objects.
• A rule on not instantiating abstract classes.
• A rule on not using the command syntax.
• A rule on not using iterator variables outside the for loop.
• A rule on having the object of the class as the first output of a constructor.
• A rule on a consistent class object name.
• A rule on not calling functions with more input arguments than are expected.
• A rule on classes not implementing properties inherited from superclasses.
• A rule on not having Java dependencies in your code.
• A rule on having the same method access permissions as those from of a superclass.

Release 1.1.0 (August 2022)

Added

• A rule on not using tab characters.
• A rule on having all properties blocks before all methods blocks in classdef files.
• A rule on including an else section to ifs that have an elseif section.
• A rule on not using undocumented MATLAB-installed functions.
• A rule on not missing method declarations and implementations.
• A rule on mismatches between input and output declarations and implementations for methods.

Changed

• The descriptions of the severity levels to match those currently used by TIOBE's TICS.
• The severity levels and priorities of several rules.

Release 1.0.0 (January 2022)

Initial release