{"id":230000,"date":"2023-07-26T02:47:43","date_gmt":"2023-07-26T09:47:43","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/java\/?p=230000"},"modified":"2023-07-26T07:20:09","modified_gmt":"2023-07-26T14:20:09","slug":"java-on-visual-studio-code-july-2023","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/java\/java-on-visual-studio-code-july-2023\/","title":{"rendered":"Java on Visual Studio Code – July 2023"},"content":{"rendered":"

Hi everyone, welcome to our July update for Visual Studio Code for Java! In this blog we are going to provide you an exciting update about our improved decompiler functionality. Additionally, we are going to do a deep-dive into our code completion. Let’s get started!<\/p>\n

Decompiler Experience Upgrade<\/strong><\/span><\/h3>\n

Java decompiler is essential for understanding third-party libraries, debugging, and learning from well-written code. It helps the developer to reverse engineer compiled Java bytecode back into human-readable Java source code, enhancing the productivity and code comprehension.<\/p>\n

Previously, users have reported that our extensions did not have good support of proper decompiling and debugging code. In our latest release, we have embedded a powerful Java decompiler called Fernflower (Currently an open-source project and used in IntelliJ IDEA) in our extension pack<\/a>. With this decompiler, our extension allows you to directly click into libraries and it will automatically decompile the bytecode into readable source code. Inside the decompiled code, you can debug like what you do normally. We hope this feature will greatly boost your productivity during development. Here’s a simple demo.<\/p>\n

\"Decompiler<\/a>
Decompiler experience upgrade<\/figcaption><\/figure><\/p>\n

Toggling Inlay Hint on the Fly<\/strong><\/span><\/h2>\n

Inlay Hint is a popular feature in Visual Studio Code and many other developer tools. It adds inline information to the source code to help you understand what the code does, such as parameter names, parameter types, variable types and so on. However, we have heard from Java developers that sometimes these inline markers have obscured the original code and the editor becomes too crowded. Actually, Visual Studio Code has a setting that allows you to toggle inlay hints on the fly so you can turn it on\/off as you are typing the code, easily tuning your experience. The setting can be found by searching for “inlay hints” and selecting the options from the image below.<\/p>\n

\"Toggling<\/a>
Toggling Inlay Hints on the fly<\/figcaption><\/figure><\/p>\n

Here’s a simple demo.<\/p>\n

\"Toggle<\/a>
Toggle inlay hints on the fly demo<\/figcaption><\/figure><\/p>\n

Code Completion Performance Improvement Deep-Dive<\/strong><\/span><\/h2>\n

We have consistently stressed the importance of code completion performance and its critical role of boosting the developer’s productivity. In our previous blog post<\/a>, we have shown the latency improvement of our recent code performance. In this month, we are pleased to share even more progress and technical details of how we have managed to make this improvement.<\/p>\n

Reduction in code completion time (compared to previous version)<\/span><\/strong><\/h4>\n\n\n\n\n\n
Extension Version<\/td>\nAverage<\/td>\nP99<\/td>\nP95<\/td>\nP90<\/td>\nP75<\/td>\nP50<\/td>\n<\/tr>\n
1.18 (compared to 1.17)<\/td>\n13.85%<\/td>\n56.15%<\/td>\n49.36%<\/td>\n50.22%<\/td>\n13.69%<\/td>\n34.38%<\/td>\n<\/tr>\n
1.19 (compared to 1.18)<\/td>\n55.65%<\/td>\n17.19%<\/td>\n17.01%<\/td>\n15.18%<\/td>\n14.14%<\/td>\n9.52%<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

As the table shows, after 1.19 release, the code completion latency has been reduced significantly in average time and in all percentile ranks.<\/p>\n

The code completion optimization efforts are tightly linked to the Eclipse Java Development (JDT) Language Server and our work is focused on three main areas.<\/p>\n

Optimize Diagnostic Jobs<\/span><\/strong><\/h4>\n

Related Pull Requests: <\/span>PR #2587<\/span><\/a>, PR #2574<\/a>,\u00a0 <\/span>PR #2664<\/span><\/a><\/p>\n

The diagnostic jobs in the Eclipse JDT Language Server are responsible for analyzing Java source code and providing feedback on potential issues such as compiler errors and warnings. These PRs introduce optimizations to the diagnostic job processing, resulting in improved performance and reduced latency in providing code diagnostics. By fine-tuning the diagnostic analysis, developers can receive faster feedback and gain insights into their codebase more promptly.<\/span>\u00a0<\/span><\/p>\n

Optimize Request Handler Scheduling Rules<\/span><\/strong><\/h4>\n

Related Pull Requests: <\/span>PR #2637<\/span><\/a>, <\/span>PR #2641<\/span><\/a>, <\/span>PR #2643<\/span><\/a>, <\/span>PR #2659<\/span><\/a>, <\/span>PR #2660<\/span><\/a>\u00a0<\/span><\/p>\n

Effective scheduling of request handlers is vital in handling incoming code completion requests from the IDE. The mentioned PRs focus on optimizing the scheduling rules used by the Eclipse JDT Language Server to prioritize and process code completion requests efficiently. These improvements enable the server to allocate resources more effectively, resulting in reduced contention and faster response times. By streamlining request handler scheduling, developers can experience a more responsive code completion workflow.<\/span>\u00a0<\/span><\/p>\n

Optimize Completion Request Handler<\/span><\/strong><\/h4>\n

Related Pull Requests: <\/span>PR #2642<\/span><\/a>, <\/span>PR #2639<\/span><\/a>, <\/span>PR #2621<\/span><\/a>, PR #2614<\/a>, <\/span>PR #2638<\/span><\/a>\u00a0<\/span><\/p>\n

The completion request handler is responsible for generating code completion suggestions based on the context within the IDE. These PRs introduce optimizations to the completion request handling process, resulting in faster and more accurate suggestion generation. <\/span>The work was mainly focused in two areas<\/span>\u00a0<\/span><\/p>\n