How can you write reliable and scalable code for SDLC?

Coding is an art, how clean you write defines how well structured your thoughts are. Apart from scalability and reliability one of the most important stroke in art of coding is perspective of maintainability. If your code is clean and you are writing enough documentation for next generation to maintain code one can call themselves programmer instead of coder.

Code reliability and scalability are key for achieving the fast pace of Company’s growth 1) Considering volumes of data in to Solution design helps build better code - how various system users ( internal & external) interact, communicate, utilize data. How data needs to be transfer & sync. Process & underlying code to support sync and async processes in the back end. 2) Choose language or tools that works well in cloud infrastructure. 3) Follow coding standards & guidelines to modularize & bulkify the code. 4) Reliability- Clear requirements and better mapping between requirements to tech stories to test case suite gives more quality output. 5) Ensure productive Design & Code reviews, help of static code analysis at development phase.

In Enterprise softwares, often Maintainability and Readability of a software takes precedence over Performance of the software. This is because, the code once written needs to be supported for years, sometimes decades. Fancy optimal code often becomes difficult to fix/change, than Simple scalable code. To achieve longitivity of code - one needs to make sure the code is extensible at write points. It is simple and segregated into smaller maintainable units. Following typical Design Patterns and SOLID principles helps in achiving this.

Writing reliable and scalable code is a crucial part of the Software Development Life Cycle (SDLC). Reliable code ensures that your software functions correctly and consistently, while scalable code allows your software to handle increased load and growth. There are some principles and practices to help you write reliable and scalable code throughout the SDLC: Clear Requirements Gathering. Modular Design. Testing and Test-Driven Development (TDD). Code Reviews. Error Handling. Logging and Monitoring. Documentation. Scalability. Performance Optimization. Version Control. Security. Code Standards and Style. Scalable Database Design. CI/CD. Feedback Loop. Scalable Infrastructure. Monitoring and Alerting. Capacity Planning.

I strongly disagree. The first step is to identify your budget. The second step is to identify your existing technology stack (which is obviously skipped if you don't have one). The third step would be to identify what changes you want to introduce to that stack (or create if none exists). The keyword is scalability. Not all software needs to perform or scale. If you truly have those needs, then you want your programing framework and libraries to be in-harmony with your equipment and network. Once your equipment is established, then you can start thinking about languages, frameworks, and libraries as stated above. If you don't need to scale... then just have fun and start coding!

Regarding scalability of the code. In the name of scalable solution, people often build more expensive software to maintain. If a clients need can be done in SQLlite DB, you don’t need snowflake or green plum over there. The solution whatever it is has to take the financial implications of its implementation, or else it will be doomed to fail. It is usually easy for to start small, and invest more when the need arises, the opposite is always not true. Take Facebook as example they started small on MySQL and moved to a different DB later on in the game.

Following coding standards and conventions is crucial for code quality. For example, in Python, adhering to PEP 8 for naming and indentation enhances readability. Proper comments, like Javadoc in Java, provide clarity. Adhering to the MVC pattern in web development ensures a structured codebase. By doing so, you foster code maintainability, readability, and robustness, preventing issues like code vulnerabilities or syntax errors that can affect functionality.

Coding standards can be enforced through automation at build time. As well, tools to evaluate code and perform static analysis can find vulnerabilities and inefficiencies before developers even commit. The sooner these are discovered and remediated the better the quality of the code will be further downstream. In terms of coding standards don't limit yourself to spaces, tabs and parenthesis. Think about what libraries will be used, how financial calculations will be made and what algorithms such as authorizations need to be centralized. The more you automate the simple stuff the more bandwidth your team has to focus on standards for more complicated scenarios.

I would add that following coding standards and conventions is not only important in the executable code that we write, but also in our tests. In the case of unit tests, I am a proponent of the standards and conventions that Roy Osherove presented in his 2005 blog post titled “Naming standards for unit tests”. These naming standards provide a clear and concise picture of the purpose of, and expect result of, unit tests.

Important but this activity is often overlooked mainly down to time constraints. If it works it's fine... Quality of code is really connected to support needs and the 'uptime' requirement. If a bank application is down there are severe consequences.

One thing which get overlooked always is unit testing and peer review. When we are short on time this are rushed up and reuslt in a bad quality code. UT and PR are 2 most effective tool to be used at the fullest

The biggest mistake I seen made when performance testing software is a lack of realistic data. Think about what your database will look like in 1...3...5 years. Stress testing a table with 50 records is pointless if it will have 1,000,000 records in production. Write a script to randomize 1M records in your test environment. Another point, developers need to be in full ownership of their code. You should be secure and confident before you test. If you are "hoping" it will pass or "fishing" to find your defects, you don't own your code. Other points: - Log constantly during the development phase. - Use timestamps to track speed. - When performance testing, avoid testing the same records unless you are creating a baseline.

Version control tools are of critical importance to store, share, protect and collaborate on code as well as to ensure that an appropriate history of change is kept for compliance and troubleshooting of issues. Adopting a version control methodology and branching strategy that works for your team is a critical component of this process. It is usually best to adopt a common industry approach that will align with your team structure and deployment process. When testing be sure to test early and often, build your testing automation and test cases with your code and embed your testing resources in with the teams. Design and build testable code. Don't be afraid to deviate from a pristine architecture in order to facilitate testing.

In the realm of software development, the Software Development Life Cycle (SDLC) is foundational, providing structure for generating reliable code. Testing is integral, serving as a continual process to uncover vulnerabilities and ensure code quality. The future mantra embraces rapid deployment, emphasizing the importance of failing early and often. At the core of this paradigm is a relentless test team, acting as guardians of quality. A ruthless approach identifies and addresses issues proactively, turning failure in the early stages into a catalyst for innovation. This ensures a swift journey from code creation to deployment, marked by unwavering reliability

For scalability you're likely to need thread-safe software. This decision needs to be made early and its needs and ramifications understood. The code needs to follow most of SOLID principles to minimize the degree of re-work when architecture needs to be refactored - scalability is either inbuilt from the outset (see YAGNI, not very agile) or you refactor later (something you probably will need to do eventually anyway) so your refactoring skills need to be grown to the level where you can refactor architecture with comparative immunity.

I would argue that this step be done 2nd before testing and even following best practices in your coding. The more lines of code that exist, the deeper you are embedded in your decisions. You want your design and patterns established almost immediately. My experience is when I have to pivot my patterns, I stop writing clean code. I'm too busying shifting around puzzle pieces to ensure the software works and meets the business requirements. The elegance of the code dissipates with every piece of duct tape I place on a method to keep it working. Finally, remember the scientific method. Stress test your design sooner rather than later. Don't use your gut, establish metrics for performance. Measure them as many times as you can.

An example scenario where refactoring & optimization of code is inevitable is while migrating gigantic monolithic apps to micro-services architecture via lift & shift methodology. This aspect becomes more critical if code base is legacy code. As a general rule of thumb my team & myself follow below coding standards: - Always use appropriate naming conventions for methods used in source code so that anyone who reads it after 10 years or so understands instantly what a specific function does. - Documentation is must(Include jira ticket numbers & apt descriptions of code functionality via comments in source code) - Implementing code freezes - Strictly using branching, forking mechanisms for all application & infrastructure code deployments

Don't forget to consider static software analysis tools. Specific to .NET, do you have 0 warnings and 0 information messages in your Visual Studio project? Tons and tons of great feedback on every line of code you write. It's free and built-in. In 2023, there is no excuse to avoid it! As someone who hated feedback from static software analysis tools 10-15 years ago, the quality of the automated analysis has increased immensely.

Use Gen AI for review, but don't rely on it completely but for sure it can reduce your effort and increase quality of the code

Actually reviews help to identify and mitigate any potential risks and vulnerabilities in code. It also promotes coding standards and consistency across projects

In modern world, while all other aspects are getting covered but generally what a developer need to think around is security over top of everything else. Security must be embedded into design rather than a separate layer over and above. Simple things like: -Use of secrets - Authentication layer - vulnerable queries - security best practices Following security at design level solves a lot of problems in future at the same time, saves a lot of effort at later stages.

The absolute most important thing to do for reliable code is to inspect every single bug to understand how it got there, what the root causes were, and what beliefs need to change to ensure bugs don't get there by that route in the future. I find that this only really works if you start a product doing that right from the outset, else the legacy problems will make it very difficult ever to reach zero bugs.

Think about how you would test your code before you start writing your first line of code and automate the tests. When I picked up a work item a couple of years ago, we have an automated test framework in place and it forced me to think about how I would automate the tests of my code first which eventually made my code much more reliable.

Here are some tips: write reliable and scalable code, understand project requirements and design, follow best practices, use version control, and incorporate security measures. Conduct code reviews, maintain documentation, automate testing and deployment, handle errors, plan for maintenance, and gather feedback for iterative improvements.

Leverage cloud platforms for scalability and flexibility. By leveraging microservices, containers,DevOps practices, organizations can accelerate development cycles, improve application performance,improve resiliency and also reduce costs by optimal utilization of resources