Lookup Performance Optimization: Speedy Sheets: Lookup Performance Optimization Techniques

1. Introduction to Lookup Performance in Spreadsheets

When it comes to optimizing the performance of spreadsheets, understanding the intricacies of lookup functions is crucial. These functions are the workhorses of data analysis, enabling users to search for and retrieve information from different parts of a spreadsheet efficiently. However, they can also be a source of frustration when they slow down your workflow. This is often the case with large datasets where traditional lookup functions like vlookup or HLOOKUP can become cumbersome and time-consuming. The key to enhancing lookup performance lies in the judicious use of these functions, understanding their limitations, and applying best practices to minimize their impact on spreadsheet speed.

From the perspective of a spreadsheet novice, the use of lookup functions might seem straightforward—simply input the function, define the search key, and specify the data range. Yet, without proper knowledge, this simplicity can lead to inefficiency. For instance, using VLOOKUP to search through an unsorted dataset can significantly increase computation time. On the other hand, an advanced user might leverage more efficient functions like INDEX and match, which, when combined, can offer a more flexible and faster alternative to VLOOKUP, especially in larger datasets.

Here are some in-depth insights into optimizing lookup performance:

1. Prefer index-MATCH over VLOOKUP/hlookup: INDEX-MATCH is not only more flexible but also faster, as it does not necessarily require the data to be sorted. It also allows for a leftward search, something that VLOOKUP cannot do.

2. Use Array Formulas Sparingly: While array formulas can be powerful, they can also be resource-intensive. Use them only when necessary and ensure they are as compact as possible.

3. Optimize Data Range: Limit the range of your lookup functions to the necessary rows and columns. Searching through entire columns (e.g., A:A) can slow down performance.

4. Sort Data: If using VLOOKUP, sort your data in ascending order to improve speed, especially if you're using the 'TRUE' argument for approximate match.

5. avoid Volatile functions: Functions like OFFSET and INDIRECT are volatile and can cause the entire worksheet to recalculate whenever a change is made, leading to slower performance.

6. Leverage Helper Columns: Sometimes, adding a helper column to preprocess data can make your lookups more efficient. For example, concatenating two columns into one to create a unique identifier for a faster search.

7. Consider Using Tables: Excel Tables (created using the 'Format as Table' feature) can improve performance as they allow for structured references and can automatically adjust as data is added or removed.

To illustrate these points, let's consider an example where we have a dataset of employee records, and we need to find the department of a specific employee. Using VLOOKUP without sorting the data might take longer, especially if the dataset contains thousands of entries. However, by sorting the data and using INDEX-match, the lookup would be much quicker. Additionally, if we create a unique identifier by concatenating the employee's first and last names in a helper column, we can further speed up the search process.

Optimizing lookup performance in spreadsheets is about understanding the tools at your disposal and using them wisely. By considering different perspectives and applying the techniques listed above, you can ensure that your spreadsheets remain responsive and efficient, even as they grow in size and complexity.

2. Understanding the Basics of Lookup Functions

lookup functions are the backbone of data analysis in spreadsheet software, allowing users to search for data within a table or range based on a given criterion. These functions can significantly reduce the time and effort required to sift through large datasets, making them indispensable tools for anyone looking to optimize their workflow. However, understanding how these functions work and how to use them effectively is crucial for achieving the best performance.

From a practical standpoint, lookup functions can be categorized based on their search direction and flexibility. For instance, VLOOKUP searches vertically down the first column of a specified range, while HLOOKUP searches horizontally across the first row. More advanced functions like INDEX and MATCH offer greater flexibility, allowing users to specify both the row and column for a lookup.

Here's an in-depth look at the basics of lookup functions:

1. VLOOKUP (Vertical Lookup):

- Syntax: `=VLOOKUP(lookup_value, table_array, col_index_num, [range_lookup])`

- Use Case: To find a student's grade in a class list where the student names are in the first column and grades are in the second.

- Example: `=VLOOKUP("John Doe", A2:B10, 2, FALSE)` would return John Doe's grade from the list.

2. HLOOKUP (Horizontal Lookup):

- Syntax: `=HLOOKUP(lookup_value, table_array, row_index_num, [range_lookup])`

- Use Case: To find the price of a product in a row where the first row contains product names and the second row contains prices.

- Example: `=HLOOKUP("Widget", A1:Z2, 2, FALSE)` would return the price of the Widget.

3. INDEX and MATCH:

- Syntax: `=INDEX(array, MATCH(lookup_value, lookup_array, [match_type]), column_num)`

- Use Case: To locate a specific piece of data within a two-dimensional table.

- Example: `=INDEX(A1:C10, MATCH("John Doe", A1:A10, 0), 3)` would return the value in the third column for John Doe.

4. XLOOKUP (Excel 365 and newer):

- Syntax: `=XLOOKUP(lookup_value, lookup_array, return_array, [if_not_found], [match_mode], [search_mode])`

- Use Case: To replace VLOOKUP/HLOOKUP with a single, more powerful function.

- Example: `=XLOOKUP("John Doe", A2:A10, C2:C10)` would return the corresponding value from column C for John Doe.

Understanding the nuances of these functions, such as the importance of the `[range_lookup]` argument in VLOOKUP and HLOOKUP, which determines whether an exact match is required, can greatly affect the accuracy of your results. Additionally, being aware of the limitations, such as VLOOKUP's inability to look to the left of the lookup column, can help you choose the right function for the task at hand.

By mastering these functions, you'll be able to perform quick, efficient lookups that can handle even the most complex data analysis tasks, ensuring that your sheets remain speedy and your data remains accessible. Remember, the key to optimization is not just knowing which function to use, but understanding how to use them effectively to suit your specific needs.

3. Measuring Lookup Efficiency

In the quest for optimal performance in spreadsheet applications, the efficiency of lookup operations is a cornerstone. These operations, which are fundamental for data retrieval, can become a bottleneck in large datasets. The process of benchmarking lookup efficiency involves measuring the time it takes to retrieve data using various lookup functions and techniques, and comparing these times to identify the most efficient approach. This is not just about speed; it's about scalability, reliability, and the ability to handle complex queries without a hitch.

From the perspective of a database administrator, the focus might be on the optimization of indexing strategies, whereas a software engineer might prioritize algorithmic efficiency. A data analyst, on the other hand, would be interested in the practical application of these lookups in day-to-day data manipulation tasks.

Here are some in-depth insights into benchmarking lookup efficiency:

1. Function Selection: The choice of lookup function can greatly impact performance. For instance, `VLOOKUP` is a popular choice but can be slower than `INDEX` and `MATCH` combined, especially in larger datasets. `INDEX` and `MATCH` offer a two-step process that first identifies the row (`MATCH`) and then retrieves the value (`INDEX`), which can be more efficient than `VLOOKUP`'s one-step approach.

2. Data Structure: The layout of data plays a significant role. Lookups in a single, flat table are generally faster than those that require traversing multiple tables. Additionally, ensuring that data is sorted can expedite search operations, as many lookup functions are optimized for sorted data.

3. Array Formulas: While powerful, array formulas that perform lookups can be resource-intensive. They should be used judiciously, and benchmarking can help determine if the performance trade-off is worth the functionality they provide.

4. Parallel Computing: Modern spreadsheet applications can leverage multi-threading. Benchmarking should account for the ability of lookup functions to run in parallel, which can significantly reduce computation time.

5. Caching Strategies: Implementing caching can reduce the need for repeated lookups. Benchmarking the effectiveness of caching involves measuring the performance improvement when frequently accessed data is stored temporarily in a more accessible format.

6. Error Handling: Lookup functions that do not find a match typically return an error. Efficient error handling strategies, such as wrapping lookups in `IFERROR`, can prevent unnecessary calculations and improve overall performance.

7. Use of External Data: Lookups that pull data from external sources can introduce latency. Benchmarking should measure how different methods of integrating external data affect lookup times.

To illustrate, consider a dataset with 100,000 rows where you need to find the price of a product based on its ID. Using `VLOOKUP` without sorting the data might take several seconds, while an `INDEX` and `MATCH` combination on sorted data could reduce this to a fraction of a second. This difference becomes even more pronounced when the operation is repeated across multiple sheets or workbooks.

Benchmarking lookup efficiency is a multi-faceted exercise that requires consideration of various factors. By systematically measuring and comparing the performance of different lookup strategies, one can significantly enhance the responsiveness and efficiency of their spreadsheets, leading to quicker insights and more informed decisions.

4. Optimizing Formulas for Faster Lookups

In the realm of spreadsheet management, optimizing formulas for faster lookups is akin to fine-tuning a high-performance engine: the goal is to achieve maximum efficiency with the least amount of drag. This process is critical because it can significantly reduce the time it takes to retrieve information, especially in large datasets where every millisecond counts. From the perspective of a data analyst, the need for speed is balanced with the necessity for accuracy. Meanwhile, a database administrator might prioritize the scalability of the lookup operation across multiple queries and users. A software engineer, on the other hand, would delve into the intricacies of algorithmic efficiency, ensuring that the underlying code is optimized for performance.

Here are some in-depth strategies to optimize your lookup formulas:

1. Use Index-Match Instead of VLOOKUP/HLOOKUP: The `INDEX-MATCH` combination is often more efficient than `VLOOKUP` or `HLOOKUP` because it does not require the lookup column to be at the start of the range and it only examines the relevant arrays.

- Example: `=INDEX(B:B, MATCH("lookup_value", A:A, 0))` is generally faster than `=VLOOKUP("lookup_value", A:B, 2, FALSE)`.

2. Leverage Binary Search with Sorted Data: If your data is sorted, you can use a binary search approach by setting the range_lookup argument to TRUE, which is much faster than a linear search.

- Example: `=VLOOKUP("lookup_value", A:B, 2, TRUE)` will perform a binary search on sorted data in column A.

3. Minimize array formulas: Array formulas can be powerful but they are also resource-intensive. Use them sparingly and consider alternatives like helper columns or built-in functions.

- Example: Instead of using `{=SUM(IF(A:A="criteria", B:B))}`, you could add a helper column with an `IF` statement and then sum that column.

4. Optimize Use of Volatile Functions: Functions like `OFFSET`, `INDIRECT`, `TODAY`, and `RAND` can cause the entire worksheet to recalculate whenever a change is made. Replace them with non-volatile alternatives whenever possible.

- Example: Replace `=SUM(OFFSET(A1,0,0,COUNT(A:A),1))` with a dynamic named range that expands with your data.

5. Reduce Lookup Range: Limit the range referenced in your lookup formulas to the minimum necessary. This reduces the number of cells Excel needs to process.

- Example: Instead of `=VLOOKUP("lookup_value", A:XFD, 2, FALSE)`, use `=VLOOKUP("lookup_value", A:Z, 2, FALSE)` if your data only spans to column Z.

6. Use Helper Columns for Complex Criteria: If your lookup formula involves complex criteria, consider using a helper column to simplify the formula.

- Example: If you're looking up values based on multiple criteria, add a column that concatenates the criteria into a single lookup value.

7. Take Advantage of Table Structures: Using structured references with excel Tables can make your formulas easier to read and maintain, and can also improve performance.

- Example: `=VLOOKUP("lookup_value", Table1[Column1], MATCH("Column2", Table1[#Headers], 0), FALSE)`.

By implementing these techniques, you can ensure that your spreadsheets remain responsive and efficient, even as they grow in complexity and size. Remember, the key to optimization is not just about making individual formulas faster; it's about improving the overall performance of your spreadsheet environment. This holistic approach will save you time and frustration, allowing you to focus on the insights your data can provide rather than waiting for calculations to complete.

5. Leveraging Array Formulas and Dynamic Ranges

array formulas and dynamic ranges are powerful tools in spreadsheet software that can significantly enhance the performance of lookup operations. These techniques allow for more complex calculations and data analysis within a single, concise formula, reducing the need for multiple helper columns and minimizing the computational load on the spreadsheet. By leveraging these features, users can create more efficient and responsive sheets, especially when dealing with large datasets.

From the perspective of a data analyst, array formulas are a game-changer. They enable the execution of multiple calculations across a range of cells and then output the results in an equally sized range or a single cell. This is particularly useful in lookup scenarios where you need to compare values across a dataset and extract corresponding matches. For instance, using an array formula like `=INDEX(return_range, MATCH(lookup_value, lookup_range, 0))`, you can quickly retrieve information without the need for a VLOOKUP or HLOOKUP, which might be slower with large data sets.

Dynamic ranges add another layer of efficiency. They automatically adjust as data is added or removed, meaning that formulas referencing these ranges don't need to be updated manually. This is crucial for maintaining fast lookup times as your dataset grows or changes. For example, defining a named range with the OFFSET function like `=OFFSET(start_cell, 0, 0, COUNTA(column_range), 1)` ensures that your lookup formulas are always referencing the current dataset size.

Here are some in-depth insights into leveraging these techniques:

1. Use Array Formulas for Multiple Criteria Lookups: Traditional lookup formulas often struggle with multiple criteria. Array formulas, however, can handle multiple conditions with ease. For example, `=INDEX(return_range, MATCH(1, (criteria1_range=criteria1) * (criteria2_range=criteria2), 0))` allows you to perform lookups based on multiple criteria in a single, efficient step.

2. Combine Dynamic Ranges with Array Formulas: By using dynamic ranges within your array formulas, you ensure that your lookups remain efficient regardless of how your data changes. This combination is particularly potent when dealing with databases that are frequently updated.

3. Optimize Performance with Conditional Array Formulas: Sometimes, you only need to perform a lookup if certain conditions are met. Conditional array formulas like `=IF(condition, array_formula, "")` can prevent unnecessary calculations, thus speeding up your sheet's performance.

4. Leverage the Power of SUMPRODUCT for Lookups: The SUMPRODUCT function can act as a lookup formula by multiplying and then summing arrays. For example, `=SUMPRODUCT((lookup_range=lookup_value) * (return_range))` can retrieve the sum of values corresponding to a specific lookup value.

5. Implement Error Handling in Array Formulas: To avoid errors that can slow down performance, wrap your array formulas in error-handling functions like IFERROR. For instance, `=IFERROR(array_formula, "Not Found")` will return "Not Found" instead of an error, keeping your sheet clean and efficient.

By incorporating these techniques into your spreadsheets, you can optimize the performance of your lookups, making your sheets faster and more reliable. Remember, the key to speedy sheets is not just the formulas you use, but how you use them. Array formulas and dynamic ranges offer a level of flexibility and power that, when used wisely, can transform the way you manage and analyze data.

6. The Impact of Data Structure on Lookup Speed

The efficiency of data retrieval, or lookup speed, is a critical factor in the performance of software applications. This is particularly true for applications that handle large volumes of data, where even minor improvements in lookup speed can result in significant gains in overall performance. The choice of data structure is a fundamental aspect that influences this efficiency. Different data structures are optimized for different types of operations; for instance, some are better suited for quick insertions and deletions, while others excel at fast retrieval of data.

1. Arrays and Lists:

Arrays are one of the simplest data structures and provide fast lookups by index, with a time complexity of $$ O(1) $$. However, searching for an element by value is less efficient, with a time complexity of $$ O(n) $$, as it may require scanning the entire array. Similarly, linked lists allow for efficient insertion and deletion, but lookups can be slow, also with a time complexity of $$ O(n) $$, since elements are not indexed and must be accessed sequentially.

Example:

Consider a scenario where you have an array of employee IDs sorted in ascending order. Looking up an employee ID using the index is instantaneous. However, if you need to find an employee by their name, you would need to implement a search algorithm, such as binary search, which can improve the lookup speed to $$ O(\log n) $$ if the array is sorted.

2. Hash Tables:

Hash tables are a powerful data structure when it comes to lookup speed. They offer average-case time complexity of $$ O(1) $$ for lookups, insertions, and deletions. This is because a hash table uses a hash function to compute an index into an array of buckets or slots, from which the desired value can be found.

Example:

Imagine a phone book application that uses a hash table to store contact information. When you search for a contact by name, the hash table uses the name to compute a hash code, which directs you to the exact location where the contact's details are stored, allowing for rapid retrieval.

3. Trees and Graphs:

Binary search trees (BSTs), such as AVL trees and red-black trees, offer lookup, insertion, and deletion operations with a time complexity of $$ O(\log n) $$, provided the tree is balanced. This makes them highly efficient for dynamic datasets where data is constantly being added or removed. Graphs, on the other hand, can be optimized for lookups using algorithms like depth-first search (DFS) or breadth-first search (BFS), but their performance heavily depends on the structure of the graph and the starting point of the search.

Example:

A database indexing system might use a BST to store records. When a query is made, the system starts at the root of the tree and traverses it based on whether the sought value is greater than or less than the value at the current node, significantly reducing the number of comparisons needed to find the record.

4. Trie:

A trie, or prefix tree, is a specialized tree used to handle dynamic datasets where the dataset is a collection of strings, such as a dictionary. Lookups can be extremely fast in a trie, especially when dealing with prefixes, with a time complexity related to the length of the string $$ O(m) $$, where $$ m $$ is the string length.

Example:

Autocomplete features in search engines use tries. As a user types a word, the trie is traversed character by character, narrowing down the list of possible completions with each keystroke.

The impact of data structure on lookup speed is profound and multifaceted. Developers must carefully consider the nature of the data and the operations required by their applications to choose the most appropriate data structure. By doing so, they can optimize the performance of their applications, ensuring quick and efficient data retrieval.

7. Binary Search in Sheets

Binary search is a classic algorithm in computer science, renowned for its efficiency in searching sorted data sets. Its application in spreadsheet software like Sheets can significantly enhance the performance of lookup operations. This technique is particularly useful when dealing with large datasets where traditional lookup methods can be sluggish and inefficient. By dividing the search space in half with each step, binary search reduces the number of comparisons needed to locate a specific value, thereby optimizing the lookup process.

From the perspective of a data analyst, implementing binary search in Sheets can be a game-changer. It can reduce the time spent on data retrieval, allowing for more focus on analysis and decision-making. For software engineers, integrating binary search into spreadsheet operations can be an interesting challenge that involves creative scripting and formula construction.

Here's an in-depth look at how binary search can be applied in Sheets:

1. Preparation of Data: Ensure that the dataset is sorted in ascending or descending order. Binary search relies on this order to function correctly.

2. Identifying the Range: Define the range of cells where the search will take place. This range will dynamically change as the search progresses.

3. Midpoint Calculation: Calculate the midpoint of the range. In Sheets, this can be done using a combination of `ROUND`, `INDEX`, and `MATCH` functions.

4. Comparison: Compare the value at the midpoint with the target value. If they match, the search is successful. If the midpoint value is greater, adjust the range to the lower half; if less, to the upper half.

5. Iterative Process: Repeat the comparison and range adjustment steps until the target value is found or the range is narrowed down to a single cell.

For example, suppose you have a list of employee IDs sorted in ascending order in column A and you want to find the row number of a specific ID, say '123456'. You could set up a binary search with the following pseudo-formula:

Let start = 1, end = number of rows in column A

While start <= end:

Mid = start + (end - start) / 2

If cell A[mid] == '123456':

Return mid

Else if cell A[mid] < '123456':

Start = mid + 1

Else:

End = mid - 1

Return "Not found"

This approach can drastically reduce the number of lookup operations compared to a linear search, especially in large datasets. By leveraging the power of binary search, users can transform their Sheets into a more powerful and efficient tool for managing and analyzing data. The key to success with binary search in Sheets lies in understanding the underlying principles of the algorithm and adapting them to the unique environment of spreadsheet software. With practice and creativity, binary search can be a valuable addition to any data professional's toolkit.

8. Utilizing Scripting for Custom Lookup Solutions

In the realm of spreadsheet management, the ability to quickly and accurately retrieve data is paramount. This is where scripting comes into play, offering a powerful avenue for creating custom lookup solutions that go beyond the standard vlookup or INDEX/match functions. Scripting languages, such as Google Apps Script for Google Sheets or VBA for Excel, enable users to tailor their lookup mechanisms to their specific needs, accommodating complex criteria and large datasets with ease. By harnessing the power of scripting, users can automate repetitive tasks, integrate with external databases, and process data in ways that traditional functions cannot.

From the perspective of a data analyst, scripting can be a lifesaver when dealing with datasets that require dynamic lookups based on multiple conditions. For instance, consider a scenario where you need to match sales data with the corresponding product information. A script can be written to loop through each sale entry, check multiple product attributes, and return the most relevant product details, all while handling exceptions and errors gracefully.

On the other hand, a developer might appreciate scripting for its ability to integrate with APIs or other external data sources. This can be particularly useful for real-time data lookups, where the most current data is required for decision-making. For example, a script could be set up to fetch the latest currency exchange rates before performing financial calculations.

Here are some in-depth insights into utilizing scripting for custom lookup solutions:

1. dynamic Data handling: Scripts can be programmed to adjust lookups based on the data entered. For example, if a user inputs a date range, the script can automatically adjust the lookup parameters to match records within that period.

2. Error Checking and Validation: Scripts can include error-checking routines to ensure that the data being looked up is valid and to handle cases where no match is found, thus preventing the return of erroneous information.

3. Custom Functions: Users can create their own functions that can be reused across different sheets and workbooks. For instance, a custom function could be designed to perform a two-way lookup, matching both row and column headers to retrieve a value.

4. Performance Optimization: Scripts can be optimized to reduce the processing time for lookups, especially in large datasets. Techniques such as caching results or batch processing can significantly speed up the retrieval of data.

5. Integration with Other Services: Scripting allows for the integration of spreadsheets with other services such as databases, web services, or even machine learning models, providing a level of flexibility that is not possible with standard lookup functions.

To illustrate, let's consider an example where a user needs to find the price of a product based on its ID and the store location. A custom script could be written as follows:

```javascript

Function findProductPrice(productId, storeLocation) {

Var database = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('Products');

Var dataRange = database.getDataRange();

Var data = dataRange.getValues();

For (var i = 0; i < data.length; i++) {

If (data[i][0] === productId && data[i][2] === storeLocation) {

Return data[i][3]; // Assuming the price is in the fourth column

Return 'Price not found';

This script would loop through the 'Products' sheet, compare each row's product ID and store location to the input parameters, and return the corresponding price. It's a simple yet effective way to perform a custom lookup that could be further enhanced with additional features like caching or error handling.

By embracing scripting for custom lookup solutions, users can unlock a new level of efficiency and precision in their data management tasks, ultimately leading to better insights and decision-making. Whether you're a seasoned developer or a business professional looking to streamline your workflows, the potential of scripting is vast and waiting to be explored.

9. Best Practices and Future Outlook

As we wrap up our exploration of lookup performance optimization techniques, it's clear that the journey towards efficient and speedy sheets is both ongoing and multifaceted. The pursuit of optimal performance is a balancing act, requiring a keen understanding of the tools at our disposal and the creativity to apply them effectively. From leveraging built-in functions to crafting custom scripts, the approaches are as diverse as the spreadsheets themselves.

Insights from Different Perspectives:

1. end-User experience: For users, the immediacy of data retrieval is paramount. Techniques like indexing and using more efficient lookup formulas can significantly reduce wait times, leading to a smoother user experience.

- Example: A user employs `INDEX` and `MATCH` instead of `VLOOKUP` to speed up their real-time financial dashboard.

2. Developer's Angle: Developers focus on maintainability and scalability. They might prefer using named ranges and table arrays to make the spreadsheet more readable and easier to manage.

- Example: A developer sets up dynamic named ranges that adjust as data grows, ensuring that lookup functions remain accurate over time.

3. Data Analyst's View: Analysts need accuracy and precision. They often rely on advanced techniques like array formulas or combination functions to parse complex datasets.

- Example: An analyst uses an array formula to cross-reference multiple criteria across different sheets, ensuring comprehensive data analysis.

4. System Performance: On the technical side, minimizing the computational load is crucial. avoiding volatile functions and streamlining calculations can help prevent slowdowns.

- Example: By replacing `OFFSET` with `INDEX`, a system admin reduces the number of recalculations, thus enhancing the system's responsiveness.

5. Best Practices for Optimization:

- Utilize Table Structures: Tables in Excel provide a robust framework for managing data. They automatically expand and offer structured references that are both readable and efficient.

- Prefer Non-Volatile Functions: Functions like `INDEX`, `MATCH`, and `SUMIFS` are less likely to trigger full-sheet recalculations, unlike `INDIRECT` or `OFFSET`.

- Opt for Binary Searches: When sorting data, a binary search algorithm can be implemented via scripting to halve the search time with each iteration.

- Embrace Scripting and Automation: VBA macros or Google Apps Script can automate repetitive tasks and optimize data processing.

Future Outlook:

Looking ahead, the evolution of spreadsheet software and the integration of AI and machine learning promise to revolutionize lookup performance optimization. We can anticipate more intuitive interfaces, predictive data entry, and even self-optimizing spreadsheets that learn from user patterns to pre-emptively arrange data for optimal performance. The future is bright, and as we continue to innovate and share knowledge, our sheets will only get speedier.

Read Other Blogs