Quais são as técnicas mais eficazes para melhorar o desempenho do aplicativo?

The first thing every engineer must do is 'ask questions'. Ask questions to product managers, architects, developers, and quality assurance engineers. Obtain the technical solution diagram or architecture and review each component. Analyze its dependencies, technology stack, configuration, and other relevant details. There is no such thing as "non-functional" requirements. All requirements' objective is to make the application functional and usable. Response time, error rate, throughput are "Functional" requirements. The next thing to understand is the benchmarks provided by the vendor, e.g. each cloud provider has a benchmark for their services; make sure those are taken into account for workload modelling and †est executions.

Some effective techniques: 1. Code Optimization: ◦ Identify and optimize resource-intensive code. 2. Load Balancing: ◦ Distribute incoming network traffic across multiple servers. 3. Content Delivery Network (CDN): ◦ Use a CDN to cache and deliver static assets from servers geographically closer to the user. 4. Database Optimization: ◦ Optimize database schema and indexing. 5. Compression: ◦ Compress data during transmission to reduce bandwidth usage and speed up page loading. 6. Monitoring and Profiling: ◦ Implement monitoring tools to identify performance bottlenecks. 7. Regular Performance Testing: ◦ Conduct regular performance testing and load testing to identify issues before they impact users.

Enhancing Linux User space application performance - Optimize critical sections using efficient locking mechanisms like spin locks or mutexes to prevent resource contention. - Implement multithreading with thread pools or parallel processing for improved workload distribution. - Utilize embedded C techniques like efficient data structures and algorithms to minimize memory usage and boost execution speed. - Prioritize asynchronous I/O operations and caching strategies for faster data retrieval. - Profile application performance using embedded C profiling tools to pinpoint bottlenecks and fine-tune critical sections for optimal speed

In my experience, understand the architecture of the application, tech stack of each layer - front end, database, back end. Understand the SLA of every smaller component of application and try to implement best coding practices, improve API level performance, optimise database queries, implement proper caching mechanism, validate effective configurations etc. These will improve application performance to a good level.

Today every application is resource intensive, so in my opinion - every application should adapt the caching mechanism, mobile first approach as nowadays we are more on smartphones.

One thing I've found helpful is mocking the application environment during testing. This provide a baseline to simulate various scenarios without relying on the actual production setup. Additionally, optimizing database queries by indexing frequently accessed fields has notably enhanced our app's performance. Another key aspect has been employing caching mechanisms for repetitive data requests, significantly reducing the load on the servers and improving response times. These measures, combined with code profiling to identify and resolve bottlenecks, have been instrumental in boosting an application's performance.

During the designing or development phase, one should always consider the bigger picture of the whole project / system and not only the visible subset of it which is specific for a particular functionality. By doing this, not only we optimise the complete life cycle of that functionality, but by generalisation, it also aids in speeding up of development of other functionalities. We must also ensure whatever we implement requires minimal usage of network heavy operations or the operations involving heavy processing should be decomposed into smaller operations based on the scenarios, which not only improves performance, but also helps in check pointing for each successfully completed steps.

Richard Feynman once said "What I cannot create, I don't understand". That means that you really need to understand the principles and don't be afraid to create POCs to get the full picture. Keep your peers on board with your decisions and ask for feedback during the design phase when needed.

Optimizing performance is a pivotal consideration for every application. It's an ongoing endeavor that demands attention throughout all project phases. To ensure top-tier performance, it's essential to constantly prioritize the end-user experience or the specific component interacting with the application under test. A prime illustration of this is the implementation of a Content Delivery Network (CDN), which can dramatically enhance performance by efficiently delivering web resources from the closest edge location to the user.

If an application is not designed with performance in mind from inception stage, its never going to perform as well as it could. As Performance advocates, performance architects should be involved in application design to ensure certain performance related decisions are not overlooked by the business. We have seen many a times that following scenarios may hinder an application's performance: 1. Trying to deliver more features in less time. 2. Some functional or security related features may take higher priority which can degrade application performance. 3. Increasing technical debt over time. 4. Focus on only one area of product like functionality or modern UI or high security 5. Limited knowledge of design team when it comes to performance

Continuous testing should be a norm in any project with good application performance as an objective. We cannot wait for 5-6 months to test an application just to get the bad news that the application is not performing as expected. At that stage, the cost of going back to change code or architecture can be a costly affair. Good performance with clear objective has to be part of every stage in a product's lifecycle. Everyone should test or validate their code against a clear set of objectives set in requirement gathering stage. This can be achieved by a sense of ownership at all levels. Ownership brings accountability!

Bottlenecks can manifest at various points within the architecture, making it crucial to prioritize optimized code for enhanced performance. To address performance issues early in a project, it is important to use techniques like unit testing, profiling, peer reviews, and system testing.

Consider this - what's the point of testing something if you cannot measure what you test! And when it comes to performance testing, in-depth component level measurement is paramount. There should be no dark areas in an architecture where we are not aware what's happening. So ensure that all components are reachable and have good performance measurement tools or utilities in place.

Quality assurance is a shared responsibility, where every team member plays a vital role. It involves the development of an effective test strategy, thorough test execution, meticulous results analysis, and the identification of bottlenecks and recommendations. Employing a range of performance testing methodologies is essential for establishing a performance baseline. These include load testing, stress testing, endurance testing, spike testing, database performance testing, chaos engineering, observability, and more.

Adding to the above , if the cpu is getting utilised at very low percentage ,a check can be made on number of threads whether required number threads are getting created or if there is scope to increase their number. Also auto scaling can be enabled based on the number of requests the service is receiving if the service is i/o intensive instead of cpu instensive

Any piece of code can potentially be optimized, but it's essential to consider whether optimization is truly necessary before making adjustments. For instance, in the case of Java Virtual Machine (JVM) arguments, there are numerous options available for debugging, tuning, and more. In many cases, the default arguments suffice, and there's no need to fine-tune each and every argument unless you encounter specific issues in a production environment.

In the absence of robust monitoring and observability within a system, gaining insights into its inner workings when issues arise can be challenging. Therefore, it's crucial to deploy and implement observability across all components. This allows engineers to stay informed about whether any upstream or downstream components are meeting their Service Level Agreements (SLA). Designing intuitive dashboards, implementing a fatigue-free alerting system, and utilizing logs analytics systems all contribute to more effective issue debugging in a production environment.

Performance stands as a pivotal quality factor in software. The pursuit of performance enhancement is an ongoing endeavor. With every line of code written by a developer, there's potential for an impact on performance. Therefore, it's of utmost importance to integrate performance considerations from the very beginning of the software development process, encompassing design and quality procedures.

Improving application performance is a critical aspect of software development. few tips to consider: - Caching: In-Memory Caching: Cache frequently accessed data in memory to reduce database or disk I/O. Content Delivery Network (CDN): Distribute static assets across servers globally. - Concurrency and Parallelism - Distributed Architecture: Microservices: Consider a microservices architecture for scalability and maintainability. In addition to the above techniques, there are a number of other things: -Use a lightweight framework. -Minimize the number of third-party libraries. -Use a compiler optimizer. -Use a profiler.