Demystifying Double Entry Accounting Algorithm: A Practical Guide for Software Engineers
Tags: dart, finance, accounting, algorithms
Published: 2023-06-15 07:08:08

## Introduction:

In the world of finance and business, accurate record-keeping is crucial for understanding an organisation’s financial health. For software engineers working on financial software or systems, having a solid understanding of double entry accounting is essential. This practical guide aims to demystify the principles of double entry accounting and provide software engineers with a practical code implementation that can be integrated into their projects.

## Understanding Double Entry Accounting:

**_The Core Principle:_**
Double entry accounting is a systematic approach that ensures every financial transaction is recorded in at least two accounts. An account represent a bucket or basket that holds value. Value here means balances or money in other words.

The Generally Accepted Accounting Principles (GAAP) are a set of accounting standards and guidelines used to prepare financial statements in accordance with a common framework. GAAP provides consistency, comparability, and transparency in financial reporting.

Let’s now discuss the commonly used categories of accounts in GAAP:

**_Assets:_**
Assets are economic resources owned or controlled by a company that has future economic value. They can be tangible (physical items like cash, inventory, or property) or intangible (non-physical assets like patents or trademarks). Examples include cash, accounts receivable, property, equipment, and investments.

**_Liabilities:_** 
Liabilities are obligations or debts owed by a company to external parties. They represent claims on the company’s assets. Examples include accounts payable, loans, salaries payable, and accrued expenses.

**_Equity:_**
Equity represents the residual interest in the assets of a company after deducting liabilities. It is the owner’s or shareholders’ claim on the company’s assets. Equity includes common stock, retained earnings, and additional paid-in capital.

**_Revenues:_**
Revenues are the amounts earned by a company from its primary business activities, such as sales of goods or services. They increase equity. Examples include sales revenue, service revenue, and interest income.

**_Expenses:_** 
Expenses are the costs incurred by a company in generating revenues or maintaining its operations. They decrease equity. Examples include salaries and wages, rent, utilities, advertising expenses, and depreciation.

**_Drawings:_**
Drawings are withdrawals of assets made by the owner(s) from the business for personal use. Drawings reduce the owner’s equity and are not considered business expenses.
These categories provide a framework for organising and classifying financial transactions, making it easier to track and analyse the financial health of a company. It is important to adhere to GAAP guidelines to ensure accurate and reliable financial reporting.

This system follows the principle of duality, which states that every transaction has equal and opposite effects on at least two accounts, meaning that value flows from a source account to a destination account. This ensures that the accounting equation

`Assets = Liabilities + Equity`

remains in balance. It must be noted the above equation can be expanded to accommodate the Revenues , Expenses and Drawings. Equity is derived from

`Equity = Common Stocks + Paid Up Capital + Retained Earning).`

`Retained Earnings = Revenues — Expenses.`

Therefore rewriting the equations as

`Assets = Liabilities + ((Common Stocks + Paid Up Capital) +(Revenues — Expenses) — Drawings))`

Traditionally an account is usually represented in a T format meaning it got two sides left (Debit — DR) and right (Credit — CR).

![account t-format](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9obla3iz4v9t085q404m.png)

To change value (increase or decrease balance) in an account involves posting the respective value (change) on either side in what is referred to as “making or posting debits or credits”. there are accounts that are increased by posting on debit side while others on credit side.To easily remember which accounts increase by debiting or crediting use “DEALER” acronym as shown below.

![dealer](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/yhgpvw1pi88mc2jksiul.png)

This principle guarantees that the debits and credits are balanced, providing accurate financial reporting. Software engineers familiar with data structures and algorithms can think of double entry accounting as a precise balance of financial information.

Any organisation financial transaction will basically be detailing movement or flow of value from one account type to another account type. By using this principle then we credit the source of value and debit the destination account.To illustrate the concept let’s take an example of a business transaction.

Example:

Mr. Mwaura took a bank loan of 50,000 on 12th June 2023 to finance his spare parts business. How would you represent the transaction in a double entry format?

Solutions:

First thing is to identify where the value is flowing from to its destination, in this case source is Loan Account and destination is Business Bank Account. Therefore we CR -> Loan Account and DR -> Bank Account with the value as illustrated below.

![sample transaction](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ugdhicdfchjoama9jo0a.png)

As seen with the example above the most important aspect of accounting is business transaction analysis. When done correctly you are able to make any type of posting with ease even those that you may not have idea at the beginning of your project. In the future posts we will be exploring more of this business transaction and how to categorise them and make correct accounting posts.

Journals, Ledgers, Accounting Period and Financial Reporting

**_Journals:_**

From the above examples we have done “postings” to the two accounts thus underlining the double entry concept where: a transaction is recorded in minimum two accounts. There are however some complex transactions that span into multiple entries as we will see in future posts.

In accounting language “posting” is known as journalising or in simple journal entries and a collection of them known as journals. They are described as the books of original entry.They serve as a primary source of data entry and provide a detailed record of each transaction.Its important to understand that by following the double entry accounting principle you are subscribing into an immutable way of thinking where every fact is recorded once and no changes are made to them directly, in case you want to make changes to accounting post you will need to make new sets of postings also known as “contra entries” or reversing entries. This makes the principle highly auditable and easy to identify errors of commission and omission.

**_Accounting Period:_**

An accounting period refers to a specific span of time for which financial transactions and activities are recorded and summarised. It can be a month, a quarter, or a year. The purpose of defining accounting periods is to facilitate the measurement and reporting of financial information in a systematic and consistent manner.

**_Ledgers:_**

Ledgers are the second stage of the accounting process and serve as a central repository for all accounts. Each account has its own ledger, which contains a running balance and summary of all related transactions. Ledgers provide a consolidated view of individual accounts and their balances. They are typically organised into separate general ledgers and subsidiary ledgers for specific accounts like accounts receivable or accounts payable.

**_Financial Reporting:_**

Financial reporting involves the preparation and presentation of financial statements that communicate the financial performance and position of a company to external users. The financial statements are prepared in accordance with GAAP or other applicable accounting frameworks.

The key financial statements include:

**_Income Statement:_**
Also known as the profit and loss statement, it reports the revenues, expenses, and resulting net income or loss over a specific period. It helps assess the profitability of a company.

**_Balance Sheet:_**
The balance sheet presents the financial position of a company at a specific point in time. It shows the company’s assets, liabilities, and equity, reflecting the accounting equation (Assets = Liabilities + Equity).

**_Statement of Cash Flows:_** 
This statement provides information about the cash inflows and outflows from operating, investing, and financing activities. It shows how cash has been generated and used during a specific period.

**_Statement of Changes in Equity:_** 
This statement details the changes in equity accounts, including contributions from shareholders, net income, dividends, and other adjustments.

**_Notes to the Financial Statements:_**
These are additional disclosures that provide further explanations, clarifications, and details about the financial statements and accounting policies used.

**_Other Reports:_**
In addition to the financial statements, various reports can be derived from the financial data, including:

**_Budget Reports:_**
These compare actual financial results with the budgeted amounts to analyse variances and evaluate performance.

**_Ratio Analysis:_**
This involves calculating and interpreting financial ratios to assess liquidity, profitability, solvency, and efficiency of a company.

**_Management Reports:_**
These reports are prepared for internal management and can include performance reports, cost reports, and forecasts.

These reports and financial statements play a crucial role in providing relevant and reliable information to stakeholders, aiding decision-making, and assessing the financial health of a company.

### **Transitioning from Paper Accounting (T-Format) to Digital Accounting**

Suppose a business currently maintains its accounting records using a paper-based T-Format. They record transactions manually in a physical ledger, with separate columns for date, description, debit, and credit amounts. With digital accounting the above T-Format account would be replaced with for instance an excel worksheet to look like this.

We’ll focus on a few common accounts: Cash, Accounts Receivable, Sales Revenue, Cost of Goods Sold, and Inventory.

Here’s how the account postings might look in Excel:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/25g8e4hn81nfyhjl6zia.png)

In this example, the columns represent the different elements of the account postings:

Date: The date of the transaction.
Account: Account involved in the transaction.
Description: A brief description or explanation of the transaction.
Debit ($): The amount debited to the account (if any).
Credit ($): The amount credited to the account (if any).
Balance ($): The updated balance after the transaction is recorded.
From the above transitioning it can be noted that it’s less hairy when dealing with many accounts and many transactions. Since this blog is targeted to software engineers who may be interested in how then one can solve the double entry accounting principles using available data structures. In the next section we explore the components of the principle and how we can use object oriented programming to solve the problem.

#### 2. Implementing Double Entry Accounting in Code:

To implement double entry accounting in code, we’ll break down the key components and classes required. Let’s explore the code implementation step-by-step:

![Architecture](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p7sxe7j0wusycudcihua.png)

**_Designing the Account Class:_**

The Account class represents specific financial categories such as assets, liabilities, equity, revenues, expenses, and drawings. It includes properties like account ID, name, type, and optional code and path. Here's an example implementation:

```
class Account {
  final String accountId;
  final AccountType accountType;
  final String name;
  final String? code;
  final String? path;

Account({
    required this.accountId,
    required this.name,
    required this.accountType,
    this.code,
    this.path,
  });
  // Additional methods and overrides
}
```

**_Recording Transactions:_**

Transactions, represented by the Tx class, capture the events or exchanges that impact a company's financial position. Here's an example implementation:

```
class Tx {
  final String txnId;
  final DateTime date;
Tx({
    required this.txnId,
    required this.date,
  });
  // Additional methods and overrides
}
```

**_Journalising Debits and Credits:_**

Journals serve as the primary records of individual transactions within an accounting system. The Journal class captures essential information such as journal type, accounts involved, transaction IDs, amounts, and descriptions. Here's an example implementation:

```
class Journal {
  final String journalId;
  final String owner;
  final JournalType journalType;
  final String account;
  final String? tx;
  final String? party;
  final double debit;
  final double credit;
  final String? description;

  Journal({
    required this.journalId,
    required this.owner,
    required this.journalType,
    required this.account,
    this.tx,
    this.party,
    required this.debit,
    required this.credit,
    this.description,
  });

  Journal.create({
    required String account,
    required double amount,
    String? description,
  }) : this(
          journalId: Uuid().v4(),
          journalType: JournalType.cr,
          owner: "",
          account: account,
          tx: "",
          debit: 0.00,
          credit: 0.00,
          description: description,
        );

  @override
  String toString() {
    return 'Journal(journalId: $journalId, owner: $owner, journalType: $journalType, account: $account, tx: $tx, party: $party, debit: $debit, credit: $credit, description: $description)';
  }
  // Additional methods and overrides
}
```

**_Managing Financial Information:_**

Setting up the Accounting System: Before recording any transactions, software engineers need to set up the accounting system. This involves defining the company’s details, creating accounts, and initializing necessary data structures. The Books class provides methods for setting up the company and adding accounts. Here's an example implementation:

```
abstract class Dea {
  void setupOwner({
    required String name,
    String? phone,
    String? email,
  });
  void addAccount({
    required String id,
    required AccountType accountType,
    required String name,
    String? code,
  });
  void transact();
  void debit({
    required String account,
    required double amount,
    String? description,
  });
  void credit({
    required String account,
    required double amount,
    String? description,
  });
  void commit();
  void postTransaction({
    required Tx tx,
    required List<Journal> entries,
  });
}

class Books extends Dea {
  late final Owner owner;
  late final List<Account> accounts;
  late final List<Party> parties;
  late final List<Tx> transactions;
  late final List<Journal> journals;

  List<Journal> _journals = [];
  late Tx _tx;

  @override
  void setupOwner({
    required String name,
    String? phone,
    String? email,
  }) {
    // setting up the base owner info
    owner = Owner(
        name: name,
        email: email,
        phone: phone,
        profileType: ProfileType.business);
    // initialize all books storage units
    accounts = [];
    parties = [];
    transactions = [];
    journals = [];
  }

  @override
  void addAccount({
    required String id,
    required AccountType accountType,
    required String name,
    String? code,
  }) {
    // validate account is properly added
    final account =
        Account(accountId: id, name: name, accountType: accountType);
    accounts.add(account);
  }
  // Additional methods for transactions, balancing, etc.
}
```

**_Recording Transactions:_**

The Books class provides methods like transact(), debit(), credit() and commit()to record transactions using the double entry accounting principle. Here's an example implementation:

```
class Books {
  // Existing code
 @override
  void transact() {
    _tx = Tx(txnId: Uuid().v4(), date: DateTime.now());
  }

  @override
  void debit({
    required String account,
    required double amount,
    String? description,
  }) {
    try {
      final d = Journal.create(
              account: account, amount: amount, description: description)
          .copyWith(
              owner: owner.name,
              journalType: JournalType.dr,
              tx: _tx.txnId,
              debit: amount);

      _journals.add(d);
    } catch (e) {
      print("{debit}: ${e.toString()}");
    }
  }

  @override
  void credit({
    required String account,
    required double amount,
    String? description,
  }) {
    try {
      final d = Journal.create(
              account: account, amount: amount, description: description)
          .copyWith(
              owner: owner.name,
              journalType: JournalType.cr,
              tx: _tx.txnId,
              credit: amount);

      _journals.add(d);
    } catch (e) {
      print("{credit}: ${e.toString()}");
    }
  }
  // Additional methods for balancing, committing, etc.
}
```
**_Ensuring Balancing and Committing Transactions:_**

Balancing and Committing Transactions: The Books class includes methods like commit() to ensure the double entry accounting principle is maintained, and transactions are properly committed. Balancing the accounts and verifying the accuracy of the financial statements is a critical step. Here's an example implementation:

```
class Books {
  // Existing code
@override
  void commit() {
    try {
      final balance = BooksBalances.init();
      // enforce double entry rules
      if (_journals.length <= 1) {
        throw "{commit} a double entry accounting transaction must have a minimum of two journal entries";
      }

      for (var element in _journals) {
        final account = getAccount(element.account);
        final amount = element.journalType == JournalType.dr
            ? element.debit
            : element.credit;

        final _ = element.journalType == JournalType.dr
            ? balance.debits += element.debit
            : balance.credits += element.credit;

        // switch against account type
        switch (account.accountType) {
          case AccountType.assets:
            // adding amount to assets
            balance.assets += amount;
            break;
          case AccountType.liabilities:
            // adding amount to liabilities
            balance.liabilities += amount;
            break;
          case AccountType.equity:
            // adding amount to equity
            balance.equity += amount;
            break;
          case AccountType.revenues:
            // adding amount to revenues
            balance.revenue += amount;
          case AccountType.expenses:
            // adding amount to expenses
            balance.expenses += amount;
            break;
          case AccountType.drawings:
            // adding amount to drawings
            balance.drawings += amount;
            break;
          default:
        }
      }
      print(balance);

      if (balance.debits != balance.credits) {
        final note = balance.debits < balance.credits
            ? 'debits less by ${balance.credits - balance.debits}'
            : 'debits more by ${balance.debits - balance.credits}';
        throw "{commit} a total debits must always equal total credits for double entry accounting transaction. $note";
      }

      if (balance.assets != balance.sources) {
        throw "{commit} transaction does not satisfy double entry equation: {assets = liabilities + equity / assets = liabilities + (capital - drawings) + (revenue - expenses)} ";
      }

      postTransaction(tx: _tx, entries: _journals);
      print("{commit} successful");
    } catch (e) {
      print("{commit}: ${e.toString()}");
    }
  }
  // Additional methods for financial statements, reporting, etc.
}
```

**_Conclusion:_**

Understanding the principles of double entry accounting is crucial for software engineers working on financial systems. By implementing the concepts in code, developers can build robust and accurate accounting solutions. In this guide, we’ve explored the core principles of double entry accounting and provided a comprehensive code implementation using Dart. With this knowledge, software engineers can enhance their financial software and contribute to accurate financial record-keeping.

By combining the theoretical understanding of double entry accounting principles with the practical code implementation provided, software engineers can now confidently build financial systems that adhere to accurate record-keeping and financial reporting standards.

This was to serve as the basics of the double entry accounting topic and i will be exploring in details more concepts of the same.

In the next issue i will be delving more into the algorithm integrating it with a relational database such as Postgres to enhance data persistence as well as make the solution more scalable. I will also be show casing how you can generate the various reports. Stay tuned for the next issue. Feel free to ask question.

Complete code for this blog can be found 
[here](https://github.com/clansofts/dea).