seen from China
seen from Australia
seen from China
seen from Malaysia
seen from China
seen from China
seen from China
seen from United States
seen from China
seen from Malaysia
seen from Maldives
seen from Maldives
seen from United States
seen from United States
seen from Belgium
seen from Hong Kong SAR China
seen from United States
seen from China
seen from United States
seen from United States
PureCode company | Performance and Scalability
Performance and scalability are key considerations when choosing a JavaScript framework. These factors directly impact the user experience and the application’s ability to grow and handle increasing loads. React and Vue both use a virtual DOM to improve performance, which is a key factor in the development of web applications.
Introducing Servlet 4.0 Server Push Using Spring Boot 2.1 - #Ankaa
Introducing Servlet 4.0 Server Push Using Spring Boot 2.1 In this article, we will be talking about Server Push Technology that is actually part of the HTTP/2 spec. The most important feature of Servlet 4.0, due to HTTP/2, is the implementation of the server push capability. The concept behind this technique is that if the client/browser requests a... https://ankaa-pmo.com/introducing-servlet-4-0-server-push-using-spring-boot-2-1/ #Http2 #Java #Performance_And_Scalability #Server_Push #Servlet_40 #Spring_Boot #Spring_Boot_20 #Tutorial
Load Testing
Load testing is a critical step to the successful launch of any web based application as traffic patterns can fluctuate greatly. Load tests are meant to simulate real-world traffic patterns (vs a performance test which is to identify bottle-necks by throwing large loads of traffic on an application quickly). Without load testing you are putting your users on the hook for testing your application and hoping it doesn't crash on them.
Load testing consists of 3 major tasks: 1. Prepare 2. Test 3. Analyze
Prepare
You need to do some prep work before you can start testing. Having a good plan will avoid wasted time and allow the test to be replicated in the future.
Identify the Test Path
Identify the users primary path; if this is an existing application look at analytics data to identify the common user paths/pages they access, if its a new applicaation you will need to make an educated guess. Next look at all the other areas of the application. Which areas interface with other systems? Which areas have heavy processing routines? Areas less used could have an impact on primary path users. (e.g. user "A" looks up order history and causes a delay in serving SQL requests; meanwhile user "B" is trying to view a product to purchase but cant get product data because SQL is trying to fill order history for user "A")
Identify Test Metrics
Trying to replicate real-world behavior is pretty much impossible but we can get close. Using analytics data if available or making an educated guess, identify the following which will inform the test configuration:
Total number of users
Duration of test
Number of users to star with (ramp them in how you think traffic will come in)
Think-time between request (how long a user spends on a page)
Percent of users executing each path (80% common path, 20% less common, etc.)
Configure Test Systems/Data
Ideally you can replicate your production environment with 100% accuracy; however, thats often cost prohibitive so do your best to replicate or test against production (will require downtime, user notifications, data restore, etc.). Take a snapshot of the production database to test against. Retain this as you will want to use it for future tests as database size can impact performance, using a consistently sized database will provide more accurate result measurements. Make sure all system owners are aware of the test so they dont shut down thinking its a denial of service attack.
Write Test Scripts
There are a variety of tools to program load tests with. Visual Studio Test Edition and Blitz.io are two platforms I have used and liked. You can also work with a third-party vendor such as Soasta (which I have also enjoyed working with) to script and run the tests.
As you write the test scripts run them with one or two users ensuring there are no errors, checking logs, servers, databases, etc. for accurate test execution.
Setup Performance Monitors
Setup performance monitors to watch the system behavior during the test. Load test tools give you outside visibility to what is happening but to learn about bottlenecks you need visibility inside your systems. With the performance monitors setup run 2 users through the test scripts and ensure data is being captured accurately.
Request execution time
Request wait time
Requests current
Requests queued
Requests rejected
Request error events
Processor time
Connections active
Connections Established
Connection Failures
Requests per second
Requests per transaction
Deadlocks
etc.
Execute the Tests
The day has finally come, you are well prepared and ready to execute your load tests. A checklist helps ensure the test scenarios, data, systems and monitors are configured properly. It sure sucks to run a test and realize you weren't capturing data or get shutdown because someone wasn't notified.
Before Test
1. Notify system owners of test 2. Performance monitors turned on and recording 3. All systems up and configured for test 4. Data restored 6. Test scripts and performance monitors working
Run the Test
1. Run tests 2. Monitor systems and test metrics for issues
After Test
1. Save monitor reports (systems and load test software) 2. Turn off performance monitors 3. Notify system owners testing complete
Analyze the Results
Look at the data and see when requests durations start to take longer to execute. Compare that to system monitor data. Often times you will see requests start to queue up on the web applicaiotn server and other systems like a database report fewer requests per second, indicating that database operations are backing things up. Other times you may see a web application server CPU spike as it cant process the requests fast enough. There are a ton of issues that can arise based on your application. Be scientific in your research and follow the data to the cause. If you don't reach a performance issue increase traffic and test again. There is a threshold somewhere, maybe its beyond your concern.
Web Performance Tools
Load Testing
Blitz.io
Soasta (Third-Party Service)
Monitoring
New Relic
HTML/CSS/JS Tools
Coding Tools
Can I Use
JSON Validator
Design Inspiration and Resources
Web designer Depot
Performance Tools
Google Website Optimization Test
Yahoo YSlow Optimization Test
Mobile Website Optimization Test
Performance and Scalability
Performance and scalability is often overlooked and/or not thought about until your application falls on its face. No one likes going through that... I never want to do it again...
Cloud hosting helps but is not the end all be all to performance and scalability. Performance needs to be addressed from the start of the project and baked into the architecture. Cloud computing and CDNs can help you scale your application but the architecture should be sound with or without these services.
So what do you need to think about and do to ensure you don’t end up with egg on your face? Let's dive in.
1. Caching
Database/Object caching on the server side can prevent repetitive routines and queries across systems. This can greatly improve backend processing performance and speed of the overall application. (Best used when accessing data common to a large set of users.)
Output caching is super powerful as it basically takes a snapshot of the rendered page and serves that to users until the cache expires. These days we can use JavaScript and REST endpoints to workaround many of the restrictions we used to face with output caching. (Best used when delivering content that doesn’t change frequently.)
Browser caching via the expires header is also very powerful as it eliminates HTTP requests until the expires date has passed. Be careful with this as your users browsers wont get the latest version of the file until their expires date passes. Thus the HTML source page should usually not set an expires header. As a workaround you can change the file name and update your code so it forces a new download.
Distributed Caching is a must in distributed environments (load-balanced, cloud). Software such as Memcached will make this easy. A system such as this will allow multiple CPUs to share cache data preventing duplicate work and synching issues.
2. HTTP Optimizations
One of my favorite books on this topic is "High Performance Websites" from O'Riley (http://shop.oreilly.com/product/9780596529307.do?green=7BE80B82-62E7-5861-AB4A-91C967054FAA&intcmp=af-mybuy-9780596529307.IP). It's a great resource to have at your desk for quick reference.
Reducing the number of HTTP requests will significantly help improve the speed of your applications. There are several ways to do this and tools such as GRUNT and SASS can greatly simplify this process.
* Combine CSS files * Combine JS files * Use CSS Sprites
Delay HTTP requests when possible. If content is length wait until a user start scrolling to load it. If you have a UI element that only reveals pieces of content at a time; such as a, carousel, tab switcher or accordion, delay loading the content/images for those items until necessary. Also don't leave blank space on your page that makes it look broken, show a placeholder or loading graphic.
Enable file compression to reduce packet sizes when transporting data across the internet. Enabling Gzip on a server is quick and the benefits are great.
Put scripts at the bottom of your page when possible. Some scripts must run first but browsers currently stop all other requests from processing when loading a script as it knows there may be routines in that script that affect the page load/rendering.
Avoiding redirects seems like a no brainer but I have seen more than a few websites that redirect here, then there, then there and finally land you on the page. Its just rude.
Once you have a solid application architecture you can snap in cloud services and CDNs to help your application scale.
3. Hardware Optimizations
Cloud Services Azure and AWS are the big players. I have worked with both and they have their each have their own pluses and minuses. From an architecture standpoint I like Azure, their services focus on specific tasks allowing the processes to be streamlined (e.g. web sites and table storage services). AWS is a bit easier to work with coming from a traditional hosting environment. Regardless of the service used plan your application architecture to take advantage of cloud services early. There are tweaks to standard architecture and considerations that need to be made when deploying to a cloud environment (same as a load balanced environment) that if not considered early can be a pain to setup later.
CDNs Leverage a CDN such as Akamai, AWS S3 or Azure Blob Storage to geographically distribute your assets closer to your users and take load off your origin server (freeing it up to process requests more quickly).
4. Test and Monitor
Test your applications performance. You don’t have to invest millions load testing your application but do some load testing to know where you stand. Use load testing to identify bottlenecks so you know what to watch for and understand how many users your application can support. Record your results so you have a baseline to reference in the future.
Lastly monitor your application on an on going basis. There is nothing worse than getting a call that your application is down. Tools such as new relic can greatly ease the monitoring process and provide early notifications if there are problems.
Hibernate mapped collections performance problems
