1. Singleton

At the top of our list is the singleton pattern. This is a creational pattern that ensures that only one instance of the class is created and shared throughout the program code. The most common reason for the pattern is the control of shared resources. for example, in your application, you may only need to create a single database connections pool or instance of logger or cache and share it throughout your application code.

This can be achieved by tracking whether an instance of a class has been created before creating a new one. If the object has been created before, the initially created object is returned instead of creating a new one.

2. Observer

This design pattern defines a one-to-many relationship between objects. It eases the propagation of state changes of one object(subject) to the other objects(observers) interested in the changes. The observer will often create a subscription on the subject, and the subject will intern update all the subscribers of that subject in case of a state change. This pattern is also known as publisher/subscriber.

for example, If you subscribe to a newspaper or magazine, you no longer need to go to the store to check if the next issue is available. Instead, the publisher sends new issues directly to your mailbox right after publication or even in advance.

The publisher maintains a list of subscribers and knows which magazines they’re interested in. Subscribers can leave the list whenever they wish to stop the publisher from sending new magazine issues to them.

3. Chain of Responsibility

A chain of Responsibility is a behavioural design pattern that lets you pass requests along a chain of handlers. Upon receiving a request, each handler decides either to process the request or to pass it to the next handler in the chain.

Imagine you're building a school management system, whenever a request is received from the client you may need to perform a set of operations ie. validation, authentication, authorization checks, and serve the request response from the cache if it exists, before processing the request.

Chain of responsibility patterns relies on transforming these operations into stand-alone objects referred to as handlers. These methods are chained together, the request object is passed to the fast handler in the chain process and if it is successfully processed this handler decides whether to pass it to the next handler in the chain or not.

4. Factory Method

This design pattern provides an interface for creating objects by providing some information about the object such as its type without providing its underlying implementation logic.

Imagine that you start a motor production factory and the first release of your motors are say trucks, but due to the high quality of your motors your customers start to request for busses too. This is good for the business, right? but there is a problem, and that is your production line was only engineered to produce trucks this means the entire production line will have to be re-engineered to support the production of busses too, easy right? what if your customer request for more different motors says motorbikes, cars.

This cycle may become expensive and tiresome for your company. Maybe it would be easy if we have a single production line that can easily be switched to different production modes, say switching to different programs without having to redesign it again.

This is the type of design problem that the factory method solves in your code, that is defining a creation interface that every object must meet. Thus making it possible to create objects of different types by simply providing information such as object type without providing the creation logic.

5. Constructor/Builder

Builder is a design pattern that lets you construct complex objects step by step. The pattern allows you to produce different types and representations of an object using the same construction code. This design pattern may be suitable, when the process involved in creating an object is extremely complex with lots of mandatory and optional parameters, an increase in the number of constructor parameters leads to a large list of constructors or when the client expects different representations for the object that's constructed.

Conclusion

In this article, we have briefed the top 5 important design patterns that you should know as a developer. This includes the singleton pattern that ensures that only one instance of the class is created and shared throughout the program code, observer patterns that define a one-to-many relationship between objects, a chain of responsibility that lets you pass requests along a chain of handlers, factory method that provides an interface for creating objects by providing some information about the object such as its type without providing its underlying implementation logic and constructor pattern that lets you construct complex objects step by step.

One of the best ways to gain insights into bottlenecks is through instrumentation. By collecting data on usage and monitoring for capacity bottlenecks, you can take advantage of data-driven insights into optimizations that will help you scale.

APIs serve large datasets, and when the client requests this data, serving it all at once can overwhelm the application's backend and the client application. If you love analogies, think of it this way: Amazon sells 12+ million products, and when a client sends a Get request to the product API loading this data to the server's memory, then transmits it to the client becomes resource inefficient.

For these reasons, it's important to chunk the response data and transmit each chunk when needed, which can at least minimize response time for requests, and make responses easier to handle. And this is where pagination, which is one of the best API scaling techniques comes in.

Pagination Techniques

We are going to explore some of the techniques that you can use to paginate an API.

1. Offset based pagination.

Limiting your response dataset by use of limits and offsets is generally the easiest and the most widely used pagination technique. To paginate this way, clients provide a page size that defines the maximum number of items to return and a page number that indicates the starting position in the list of items.

Based on these values, servers storing data in a SQL database can easily construct a query to fetch results. For instance, to fetch the fifth page of items with each page’s size being 10, we should load 10 items, starting after 40 items (skipping the first 4 pages of size 10). The corresponding SQL query would look like the following:

SELECT * FROM `items`
ORDER BY `id` ASC
LIMIT 10 OFFSET 40;

APIs, such as GitHub, support this kind of pagination. Clients can simply request with page and per_page parameters specified in the URL.

Advantages and disadvantages

Offset-based pagination is extremely simple to implement, both for clients and the server. It also has user experience advantages. It allows users to jump into any arbitrary page instead of forcing them to scroll through the entire content.

However, this technique has a few disadvantages:

i) It’s inefficient for large datasets. SQL queries with large offsets are pretty expensive. The database has to count and skip rows up to the offset value before it gets to returning the desired set of items.

ii) It can be unreliable when the list of items changes frequently. The addition of an item while a client is paginating through results could cause the client to display the same item twice. Similarly, on the removal of an item, a client might end up skipping it at the boundary.

iii) Offset-based pagination can be tricky in a distributed system. For large offsets, you might need to scan several shards before you get to the desired set of items. That said, offset paginations can be great when pagination depth is limited and clients can tolerate duplicates or missed items.

2. Cursor-Based Pagination

To address the problems of offset-based pagination, various APIs have adopted a technique called cursor-based pagination. To use this technique, clients first send a request while passing only the desired number of items. The server then responds with the requested number of items (or the maximum number of items supported and avail‐ able), in addition to a text cursor.

In the subsequent request, along with the number of items, clients pass this cursor indicating the starting position for the next set of items. Implementing cursor-based pagination is not very different from offset-based pagination. However, it’s much more efficient. Systems that store data in a SQL database can create queries based on the cursor values and retrieve results.

Suppose that a server returns a Unix timestamp of the last record as the cursor. To fetch a page of results that are older than that given cursor, the server can construct a SQL query like the following:

SELECT * FROM items
WHERE created_at < 1507876861
ORDER BY created_at
LIMIT 10;

Having an index on the column created_at in the preceding example makes the query fast. Several modern APIs, including those of Slack, Stripe, Twitter, and Facebook, offer cursor-based pagination.

Having an index on the column created_at in the preceding example makes the query fast. Several modern APIs, including those of Slack, Stripe, Twitter, and Facebook, offer cursor-based pagination.

Advantages and disadvantages

Cursor-based pagination addresses both the issues are seen with offset based pagination:

i) One of the key benefits of cursor-based pagination is performance. With an index on the column used in the cursor for pagination, even queries requiring scanning large tables are fast.

ii) The addition or removal of items does not affect the result set of a page. While paginating across results, the server returns every item exactly once. Cursor-based pagination is great for large and dynamic datasets.

However, it has a few drawbacks:

i) Clients cannot jump to a given page. They need to traverse through the entire result set page by page.

ii) The results must be sorted on a unique and sequential database column, used for the cursor value. It should not be possible to add records at a random position in the list.

iii) Implementing cursor-based pagination is a bit more complex than offset-based pagination, particularly for clients. Clients often need to store the cursor value to use it in subsequent requests.

The End!

Thanks for reading this article to this end. Hope it has been helpful and informative.

This article aims to explain what software testing is at a basic level. covers the importance of testing and some of the important testing strategies that every developer should know.

Software Testing refers to the set of activities that are carried out to examine the correctness, accuracy and completeness of software, before pushing it to the production environment.

Why Software Testing?

Software testing is important since it helps in the discovery of bugs which can cause social or economical damage to the end-users. For example, would you take the risk of boarding a plane or a ship that has not to been tested? I guess your answer is no, the same case applies to software.

When software is not tested it can cause economic or social damage to the end-users for example:

One of the biggest American market makers for stocks struggled to stay afloat after a software bug triggered a $440 million loss in just 30 minutes. The firm’s shares lost 75 per cent in two days after the faulty software flooded the market with unintended trades.

Types Of Software Testing

Though there are more than 100 software testing techniques, only a few are selected during SDLC depending on the type of development model and the application under development.

In this section, we intend to uncover some of the most widely used testing techniques that at least every developer should know.

Unit Testing

Usually, the software is broken down into units/modules/components that serve a specific functionality in the software. for example in an eCommerce application, we can have an authentication module that handles all authentication operations in the application.

This module integrates with other modules to provide a fully functional application. But before integration, it would be necessary to test this module to ensure that it's bug-free, functional and meets all the requirements and integrating it with other components will not result in the failure of the software.

This is the stage where unit testing takes part, the components are tested independently and if there are dependencies required for the module to work, these dependencies are replaced with stubs/mocks. for example, replacing a database integration with an interface that is not an actual database but mocks the database behaviour.

Note: for a test to be referred to as a unit test the tested component should not interact with any dependencies ie. database, network, files etc.

Integration Testing

After the software modules are tested to satisfaction, the modules are integrated and tested using the integration testing technique. The goal of integration testing is to detect any irregularity between the units that are integrated together.

From our earlier example assuming the authentication module and the rest of the modules have been tested to satisfaction. It's time to integrate these components together.

This test can take two-approach:

1. Big-bang, where all the modules are required to run integration tests.
2. Incremental, where tests can be run on existing modules and stubs/mocks can be used to provide the functionality of non-existing modules.

System Testing

Once all the units/modules/components that make up the application are integrated and tested, System testing also referred to as end-end testing is carried out. System testing detects defects within both the integrated units and the whole system.

In this type of test, the application is treated as a black box. The goal is to ensure the application meets the expected system behaviour without having to worry about how it works internally.

Acceptance Testing

At this stage, the software is tested for compliance with specified requirements. This ensures users' satisfaction is met before deployment.

This test involves:

1. Alpha testing, the system is tested in the development testing environment these testers are referred to as alpha testers.
2. Beta testing, the system is tested by end-users, and feedback is collected for improving the system's user experience or fixing defects. These users are referred to as better testers.
3. User Acceptance testing, this test determines whether the software meets the user's expectations.
4. Business acceptance testing, this test determines whether the software meets the business goals.
5. Contract Acceptance Testing, this is a contract that once the product goes live, within a predetermined period, the acceptance test must be performed and it should pass all the acceptance use cases.
6. Regulations Acceptance Testing, is used to determine whether the product violates the rules and regulations that are defined by the government of the country where it is being released.
7. Operational Acceptance Testing, is used to determine the operational readiness of the product and is non-functional testing.

The End!

Thanks for reading this article to this end. Hope the article was helpful and informative.