How can you ensure your data structures and algorithms are reliable and robust?

A mentor of mine often mentioned that "Code without tests is naked." While adding more code might seem productive, it sometimes only increases maintenance and potential errors. Tests don't just catch mistakes; they boost our confidence, assuring us that our code can weather any scenario.

One of the most essential steps to ensure the reliability and robustness of your data structures and algorithms is to test code thoroughly. Testing can help you detect and fix bugs, errors, edge cases, and unexpected behaviors in your code before they cause problems in our system.

Dictionary, set, and list data types are invaluable for building efficient algorithms and data structures. In the past in languages such as C those data structures did not exist and had to be implemented by the developers. C++ and Java are examples which come with standard libraries for those data types. But the most useful case is, when these data types are native data types in the language, such as with Python. In any case the data types (and operations on it) provided by the language should be used instead of re-inventing the wheel by implementing them yourself again and again.

Understanding time complexity is essential to ensure you've chosen the appropriate tool for the job. For example, iterating over an array to find a particular element will take linear time (known as Big-O of n or O(n)). In contrast, if you're using a set data structure, or a hash map, this operation will have a constant complexity. You'll be able to perform a direct look up without having to traverse the entire collection.

One of the most important aspect of writing reliable and robust DSA is by identifying the right DSA to use. Start by writing the most simple pseudo code to solve the problem and then optimize it to get a more robust solution. Meanwhile, handle any miss edge cases if they seem to miss.

It's common in a large organization to move across projects using the same technology. Imagine each individual project following a different set of coding practices and style guides. This will significantly increase the cognitive overhead of switching codebases and reduce productivity. To ensure you remove the overhead of manually keeping track individual code changes align with the best practices accepted across the organization make sure you setup automation. For example, setting up a linter and code formatter that runs as your precommit hook can remove lots of manual work. Once you do this, add CI checks to make sure that only compliant changes make it to the source repository.

Periodic review and refactoring of the code ensures the quality of the codebase does not regress over time. I've worked with many engineers who have shared that when they keep adding code over time to their projects without ensuring high hygiene their project collapses due to exponentially growing complexity. Frequently reviewing old decisions and ensuring there are no shortcuts that degrade code quality helps a lot! A big fear from refactoring is that it could break already working code. To ensure that's not a problem, just make sure you have a solid test coverage that brings you confidence that the refactoring doesn't cause regressions.

Data structures and algorithms part of fundamental in software development every engineer must understand. - Try to figure out nature of the problem - apply the most suitable data structure and algorithms - check all the edge cases for the solution developed - ask for code reviews if required / check the similar existing approach / follow the industrial best practices and standards - double check in all possible environments and do refinement if necessary

You can accelerate a lot in your career by learning from others! This could happen in many different ways: - Open source - that's what have worked for me the most. Opening a challenging codebase owned by engineers who inspire you can help you learn a ton! Advantage of open source is that you could be anywhere in the world and still review the code of some of the brightest engineers alive. - Watching videos or livestreams - I've learned a lot about different coding techniques or shortcuts that improve my productivity from watching coders on YouTube or Twitch - Mentorship from senior engineers - that's another unique hands-on experience which you should take advantage of every time when possible.