Wear your love for coding on your sleeve, on a tote bag, or on your laptop. However you want to display your passion, the brand-new JetBrains merchandise store has you covered!

Shop JetBrains Gear

What we have on offer for you

We offer a wide variety of essential gear, like T-shirts, hoodies, stickers, and pins, as well as other JetBrains and product-branded apparel and accessories. 

All of our items are made with high-quality materials to ensure that they are long-lasting and enjoyable to use, and most of our clothing is made of organic cotton. We plan to expand our product line gradually after listening to the feedback from fans. Moreover, we’re already working on minimizing our environmental footprint, and will continue doing so. 

Our items are shipped worldwide (except for some countries) from a warehouse in Germany, with delivery terms and costs varying from country to country. Check out the store FAQ for more details, and don’t hesitate to contact the Customer Support team if you have any questions.

What’s next? 

The JetBrains store has a lot of quality gear, but it still has a lot of room to grow! While we are successful in creating software development tools you love, a fan shop is a different story. 

We are still learning what makes the perfect piece of merchandise and identifying the best process for getting the products into your hands. We want to ensure that your experience with the store is as satisfying as the tools you enjoy using. 

We’ve got an experienced managing partner and store provider, Brand Addition, who’s supporting us along the way, but we are also keen to know what you think.

Stock up on JetBrains gear from our shop and show it off in action! 

Share photos or videos of yourself using our items on social media, and be sure to tag @jetbrains or our products and add the #JetBrainsGear hashtag.

Shop JetBrains Gear

Let’s spread The Drive to Develop together! 📸

Your JetBrains team

Let’s take a look at what’s inside!

C# support

Support for default parameter values in lambdas

As part of our work on supporting C# 12 language updates, we’re introducing support for default parameter values in lambda expressions in ReSharper 2023.2. In addition to the standard set of warning messages associated with recognizing this syntax, we’ve also tweaked an existing inspection, The parameter has the same default value, to account for default parameter values in lambdas. This inspection will also be triggered when an invocation has an argument value that is the same as the default value of the parameter in the invoked delegate, making the expression redundant.

New inspections for improved control over object disposal

ReSharper 2023.2 introduces two new code inspections designed to address scenarios where the state of a returned object may be negatively influenced by its early disposal or the early disposal of the object that spawned it.

When a variable is captured by a using statement, it ensures that the object is properly disposed of when it goes out of scope. Returning an object captured by a using statement can be problematic because it extends the lifespan of the returned object beyond the method scope, causing the object to be disposed of immediately after returning. This can lead to unexpected behavior and resource-related issues.

The Return of a variable captured by ‘using’ statement inspection alerts you in cases where the returned object is immediately disposed of.

Similarly, the Return of a task produced by ‘using’-captured object inspection identifies scenarios where a Task is produced by an object captured by a using statement and then immediately returned. To extend the lifetime of the disposable object enough for Task completion, a corresponding quick-fix will introduce asynchronous awaiting for that Task before its return. 

C++ support

This EAP build brings support for the C++23 standard library modules and C++20’s [[no_unique_address]] attribute, new code formatter settings, and other updates. 

For more details, please refer to this blog post.

dotTrace

Group by Thread for sampling, tracing, and line-by-line snapshots

dotTrace 2023.2 introduces the Group by Thread option and corresponding button in the Call Tree panel for performance snapshots. This option organizes sampling, tracing, and line-by-line snapshots based on individual threads, allowing for deeper insight into thread-specific performance issues. 

Using this grouping method can also give you a birds-eye view of the project’s performance, as the call trees with the most ancestors will end up at the top of the list, making any hotspots glaringly obvious. 

Once you’ve clicked on the Group by Thread toggle button, you will see the call trees organized by thread. You can navigate from one thread to another by using the keyboard, and the trees will expand at once. Red-colored percentage values to the left of the call tree indicate higher subtree power, helping you pinpoint potential performance bottlenecks at a glance. 

That’s it for now! For the full list of improvements and fixes that made it into the latest EAP build, please check out our issue tracker. As always, we’d love to hear your opinions and suggestions in the comments below.

Welcome to the June edition of PHP Annotated. We’ll recap the most thrilling developments in the PHP community over the past month, featuring handpicked news, articles, tools, and videos.

Highlights

• Happy 28th birthday, PHP!
  On June 8, PHP turned 28 years old! For a throwback, see Rasmus Lerdorf’s initial public announcement of PHP.

  Here’s to many more years of empowering developers and pushing the boundaries of web technology. Happy Birthday, PHP! 🎉🥳🎂

  The JetBrains PhpStorm team reached out to 20 members of the PHP community and asked them to name their favorite coding tracks. The result is a playlist tailored to make you even more productive while coding in PHP:

  A testament to the vibrant and diverse PHP community, this playlist features contributions from PHP greats such as Christoph Rumpel, Jordi Boggiano, James Titcumb, Matthieu Napoli, Frank de Jonge, Stephen Rees-Carter, Cal Evans, Povilas Korop, Taylor Otwell, Benjamin Eberlei, Nicolas Grekas, Eric Barnes, Ian Landsman, Derick Rethans, Caneco, Zuzana Kunckova, Brent, Tim MacDonald, Mohamed Said, and Paul Redmond.

  To commemorate the occasion, Brent also conducted an elephpant raffle on the PHP Annotated YouTube channel.

• Celebrating 20 Years of WordPress
  Not 28, but still quite an accomplishment! Congratulations!
• PHP 8.3 Alpha 1 available for testing
  The first alpha has been released, kicking off the PHP 8.3 release process. Updates will be released every two weeks on a defined schedule with the final release expected around November 23.

  A feature freeze is expected on July 18, meaning some changes might still make it into the release. The most notable changes at the moment are as follows:

  • Readonly amendments
  • Anonymous readonly classes
  • Arbitrary static variable initializers
  • Typed class constants
  • New json_validate() function
  • Dynamic class constant fetch
  • More Appropriate Date/Time Exceptions

  See What’s new in PHP 8.3 by Brent to learn more about all the changes.

  If you are on Mac, you can try PHP 8.3 with homebrew via the Nightly channel thanks to shivammathur/homebrew-php. Otherwise, Docker images are probably the best option to try it with no hassle.

  – “What is the newest PHP version?”
  – “What the latest SUPPORTED version?”
  – “When is the next version due?”
  – “When my specific PHP version will stop being supported?”

  All answers to these – on this PHP documentation page: https://t.co/VTVmWkwIBZ pic.twitter.com/anp9AUoO7F

  — Povilas Korop | Laravel Courses Creator & Youtuber (@PovilasKorop) May 17, 2023

• PHP 8.1.20 and PHP 8.2.7 have been released
  ❗ All users are strongly encouraged to update to these security releases.
• ❗️Packagist.org maintainer account takeover
  Find out what happened and whether you might have been affected.
• PhpStorm 2023.2 Early Access Program Is Open
  Preview the latest features we’ve added to the IDE ahead of the official release – for free.
• Is PHP experiencing a renaissance?
  PHP is making a comeback with its “just works” reputation. The language has evolved, becoming faster, more secure, and more enjoyable to use.

  Here are a few links about that to share with your friends who are still skeptical about PHP:

  • 📺 PHP is the future by Aaron Francis (mostly about Laravel).
  • Go with PHP by Mohamed Said.
  • 📺 PHP in 2023 by Brent.
• ChatGPT and PHP
  While Frédéric Bouchery demonstrated the ease of generating a PHP RFC draft, using the Promises RFC and Generics RFC as examples, here are some relevant links about the use of LLMs in PHP:
  • Use Laravel to build a ChatGPT plugin by Benjamin Crozat.
  • ChatGPT Plugin with Laravel by Juan Pablo Barreto.
  • Saying goodbye to WIP commit messages by Freek Van der Herten.
  • AI is a fad and programming is dead by Andrew Schmelyun.

PHP Core

Most of the Core news is covered in detail in the PHP Core Roundup series from the PHP Foundation, so we’ll only make a few brief mentions:

• 📣 RFC: Property hooks
  In this RFC, Ilija Tovillo and Larry Garfield propose to declare virtual properties with get/set functions.

  The design and syntax is most similar to Kotlin, although it also draws influence from C# and Swift.

  class User implements Named
  {
      private bool $isModified = false;
   
      public function __construct(private string $first, private string $last) {}
   
      public string $fullName {
          // Override the "read" action with arbitrary logic.
          get => $this->first . " " . $this->last;
   
          // Override the "write" action with arbitrary logic.
          set($value) => [$this->first, $this->last] = explode(' ', $value);
      }
  

• 📣 RFC: Marking overridden methods (#[\Override])
  Tim Düsterhus suggests introducing a new #[\Override] attribute. This attribute, when applied to a method, would prompt the engine to verify the existence of a method with the same name in a parent class or any implemented interfaces.

  interface I {    public function i(): void;
  }
   
  class P {
      #[\Override]
      public function i(): void {} // Fatal error: P::i() has #[\Override] attribute, but no matching parent method exists
  }
   
  class C extends P implements I {} // All good 👍
  

• 📣RFC: NameOf
  Robert Landers proposes adding a global nameof() function. This function would enable developers to swiftly and easily retrieve the name of virtually any user-defined variable, property, constant, or member.

  echo nameof($variable); // variable 
  echo nameof($object->property); // property
  echo nameof(Enum::Case); // Case
  echo nameof(Object::Const); // Const
  echo nameof(myFunction(...)); // myFunction
  echo nameof(MY_CONSTANT); // MY_CONSTANT
  

Tools

• wp-now – A local dev environment from the WordPress engineering team.
  This tool leverages WebAssembly to operate PHP on top of Node.js’ webserver. It’s faster than Docker-based environments and can be used with any PHP apps, although, you’ll have to figure out a way to run your DB.
• PHP Monitor 6.0 now available – This major update introduces the new PHP Version Manager, a new Standalone Mode that allows the app to work without having Valet installed, and more.
• pmjones/AutoShel – Automatically maps CLI command names to PHP command classes in a specified namespace, reflecting on a specified main method within that class to determine the argument and option values. The method parameters may be scalar values(int, float, string, bool) or arrays.
• jolicode/castor – A task runner and command launcher designed with a focus on developer experience, built using PHP.
• ProjektGopher/whisky – Simple and framework-agnostic CLI tool for managing and enforcing a PHP project’s git hooks across a team.
• schranz-search/schranz-search – Search abstraction over different search engines written in PHP. The currently implemented engines include Elasticsearch, Opensearch, Algolia, Meilisearch, RediSearch, Solr, and Typesense.
• TestGenAI – A tool by Tomas Votruba, the author of Rector, to generate unit tests for PHP code.
• librarianphp/librarian – A static site generator and markdown indexer inspired by Hugo and DEV, written in PHP. Read the story behind this creation.

Symfony

• Symfony 6.3.0 released
  This update introduces various new features and improvements, including a Scheduler component, webhook integration with Mailer and Notifier, an AssetMapper component, enhancements to Dependency Injection, DX improvements, new Notifier integrations, HttpClient improvements, Clock enhancements, and more. See more in the New Symfony 6.3 series.
• Say Goodbye to Null-Checking and Exceptions: Using the Maybe Monad in Symfony by Aleksei Kankov.
• We are open-sourcing our jolicode/qotd application – In the blog post Grégoire Pineau talks about using symfony/ux and advanced PostgreSQL with Doctrine in their jolicode/qotd educational application.
• Resolving values for unmapped properties when mapping request data to DTOs in Symfony 6.3+ by Dejan Angelov.
• oroinc/twig-inspector – The tool adds the possibility to find twig templates and blocks used for rendering HTML pages faster during development.

Laravel

• laravel/octane 2.0.0 released with support for Roadrunner v3.
• TomasVotruba/punchcard – This tool substitutes config arrays with fluent typed objects, enabling autocompletion in IDEs and offering other benefits.
• Laravel Package Ocean – A directory of useful Laravel packages.
• WendellAdriel/laravel-exa – Opinionated Modularized API Skeleton for Laravel.
• nasirkhan/laravel-starter – A CMS-like modular starter application project built with Laravel 10.x.
• Laravel Security Middleware by Steve (King) McDougall.
• Top 10 Laravel Audit Security Issues by Stephen Rees-Carter.
• Laravel Queues with Other Languages by Chris Fidao.
• 📺 Laravel Contact App Series by Bert De Swaef.
• 📺 Build A Full Stack TikTok Clone (Nuxt 3, Vue 3, Tailwind CSS, Laravel) – @johnweeksdev has been producing impressive full-length tutorials on building clones of existing apps with Laravel, Vue, and Tailwind. His projects include recreations of TikTok, Instagram, Netflix, Facebook, and more. Credit to Andrew Schmelyun for the recommendation.

Other frameworks

• Yii news 2023, issue 2 by Alexander Makarov.
• leafsphp/leaf 3 – A simple framework for building web apps and APIs quickly.

Misc

• Avoiding empty() in PHP by Andreas Möller.
• Technical Debt is over-used by Larry Garfield.
• Too much magic? by Matthias Noback.
• Mitigating PHP Vulnerabilities with WebAssembly – Jesús González of VMware explains how to run PHP apps in an isolated sandbox using WebAssembly.
• Unleashing the Power of High Performance Queue Services for PHP applications by Pavel Buchnev – On using RoadRunner with PHP apps.
• Diff Speeding | My developer experience – Markus Staab recounts how he significantly improved the speed of sebastian/diff. Numerous tools, including PHPUnit, Psalm, PHP-CS-Fixer, and Codeception, utilize this diffing library and now reap the benefits of these enhancements.

  Markus continued his performance investigations in Racing Rector and Doctor Rst Speedup.

• Let’s Write an Esolang in PHP by Ryan Chandler – How to write your own esoteric programming language similar to Brainf*ck in PHP.
• 📺 PHP’s type system dissected? by George Peter Banyard

Conferences

In-person events are in full swing. Check out these upcoming PHP gigs worth visiting and applying to present at:

• Laracon US – Nashville, TN, USA, July 19–20, 2023.
• CakeFest – Los Angeles, CA, USA, Sep 28–Oct 3, 2023.
• Longhorn PHP – Austin, TX, USA, November 2-4, 2023.
• SymfonyCon – Brussels, Belgium, December 7–8, 2023.

If you’re wondering when the next PHP meetup is happening, Tomas Votruba has got you covered with his lovely friendsofphp.org meetup aggregator. There is also a calendar on php.net – Events: June 2023.

If you have any interesting or useful links to share via PHP Annotated, please leave a comment on this post or send us a tweet.

Subscribe to PHP Annotated

Roman Pronskiy

Product marketing manager for @PhpStorm, had a hand in the creation of @The PHP Foundation.

Twitter | GitHub

Build 232.7295.14 is available from our website, via the Toolbox App, or as a snap package if you are using Ubuntu. Update via patch if you are using the previous EAP build.

DOWNLOAD CLION EAP

The main highlights of this build:

• CMake Parameter Info
• The ability to inspect register values during debug
• Updates to the UI
• GitLab integration

CMake Parameter Info

The Parameter Info popup shows signature variants as you type and is now available for CMake commands:

This helps you figure out which parameter to enter next, especially in case of commands that have multiple variants. Check out this page to learn about this and other CMake coding assistance features.

Inspecting register values during debug

Low-level debugging is easier when you have the ability to inspect the registers of the current frame. CLion now provides this! Together with the disassembly, memory, and peripherals views, this feature helps developers to get a better and deeper understanding of what’s going on in their code. This is especially useful in embedded debugging.

There are two ways to view the registers in the debugger tool window, in the Variables tab:

1. When you open the disassembly view, CLion automatically adds the Registers node to the Variables view for you.
2. Otherwise, call Show Registers from the context menu in the Variables tab.

By default, CLion shows registers from the first register set. You can select register sets using the Register sets sub-menu in the context menu of the Variables tab. The values are shown in hex, and the alternative values (for example, floating values for the floating-point registers) are shown nearby in gray.

Note that registers and register sets are provided by the underlying debugger and are thus different in GDC and LLDB.

User Experience

For v2023.2, we’ve refined the user experience with the Light theme by introducing the alternate Light with Light Header option, featuring matching light colors for window headers, tooltips, and notification balloons.

We’ve expanded the customization options for the new UI’s main toolbar. You can now use a dropdown menu to quickly choose actions that you want to add to the toolbar. To do so, right-click on any widget, select Add to Main Toolbar, and explore the available options.

GitLab integration

CLion and other IntelliJ-based IDEs introduce initial integration with GitLab in v2023.2, allowing you to work with the Merge Request functionality right from the IDE, thus streamlining your development workflow.

Other improvements

• The new bundled MinGW toolchain brings GCC 13.1.0.
• A Console tab was added to the vcpkg tool window to show all commands and output from them.

The full release notes are available here.

DOWNLOAD CLION EAP

Your CLion team
JetBrains
The Drive to Develop

Improved navigation from var declarations

Rider 2023.2 EAP 4 introduces improved navigation from var keywords. 

It’s common for developers to have a variable with a wrapper type such as Nullable<T>, ValueTuple<T1, T2>, or KeyValuePair<TKey,TValue> in their code. Previously, navigating from a var keyword of such variables would immediately take a developer to declarations or usages of Nullable<T> instead of the underlying type they were looking for.

All navigation actions (Go to…, Find Usages, etc.) now suggest underlying types when navigating from var for common types used to wrap other types. For example, Rider will suggest navigating to Person when using the Go to declaration action from the var keyword of a variable with the ImmutableArray<Person>? Type.

User experience

Pinned run configurations in the Run widget

To make managing multiple run configurations easier, we’ve implemented the option to pin preferred configurations in the Run widget. To add a run configuration to the Pinned section, open the kebab menu (three dots) next to its name and select Pin. If you have multiple pinned configurations, you can easily rearrange them by dragging and dropping within the list. 

File sorting by modification time in the Solution Explorer 

Rider 2023.2 EAP 4 brings the long-awaited option to arrange your files in the Solution Explorer based on their modification time. This new functionality automatically reorders the files whenever the changes in your project are saved. To enable this feature, open the kebab menu (three dots) in the Solution Explorer and then select Tree Appearance | Sort by Modification Time.

Optimized Blueprint indexing for Unreal Engine

For Rider 2023.2, we’ve optimized the way Rider handles Blueprint indexing, leading to a drastic improvement in solution loading time.

By classifying Blueprints as secondary resources, Rider is now able to index all of your code before looking at your assets. This means you get access to the rich code editing experience sooner, while the assets are still being indexed in the background.

Click here to learn more about what Blueprints support in Rider has to offer. 

Docker Compose run configuration labels

Rider 2023.2 will make it easier for you to fine-tune the run configuration of Docker Compose through the introduction of labels. By adding these bits of code to the docker-compose.yml file, you can specify how and if you want to run and debug your applications.  

For example, if you want to disable the fast mode for some of your services, you can set a com.jetbrains.rider.fast.mode: "false" label for them. If you want to disable the debug mode, use with the label com.jetbrains.rider.debug: "false". 

Web development

Volar support for Vue

Rider 2023.2 introduces Volar support for Vue to support the changes in TypeScript 5.0. This should provide more accurate error detection aligned with the Vue compiler. You can set the Vue service to use Volar integration on all TypeScript versions, under Settings / Preferences | Languages & Frameworks | TypeScript | Vue. By default, Volar will be used for TypeScript versions 5.0 and higher, and our own implementation will be used for TypeScript versions earlier than this.

Next.js custom documentation support

Next.js 13.1 now includes a plugin for the TypeScript Language Service specifically for the new app directory. This plugin offers suggestions for configuring pages and layouts, as well as helpful hints for using both Server and Client Components. It also comes with custom documentation, which means that it adds extra information to the output of the TypeScript Language Service. It’s now possible to view this custom documentation in Rider. 

CSS: Convert color to lch and oklch

Rider first introduced CSS color modification features back in version 2022.3. One of the applications for this is for changing rgb to hsl and vice versa. With our next release, we are expanding this support to include the conversion of lch and oklch with other color functions.

Working with databases

These are just a few of the updates available in the EAP 4 build:

• More options for connecting with SSL certificates.
• Use of HTTP proxy settings in the remote development process.
• WSL support for dump tools.

Click here to learn more about these and all other updates for working with databases that will be coming to Rider 2023.2.  

Notable fixes

• We’ve resolved the issue with the SSL certificate warning appearing on each startup when running Rider on macOS (RIDER-92026). 
• We’ve fixed the Go to Symbol behavior where the action would sometimes open files without scrolling to the searched symbols (RIDER-9402).
• The Separate Watches context action inside the debugger now correctly brings the Immediate Window into the view. Local variables and Immediate evaluation results are displayed in the panel to the left (RIDER-93888).

For the full list of resolved issues, please refer to our issue tracker.

That’s it for now! Please share your opinion on the latest Early Preview builds of Rider in the comments below or on social media.

We have added AI-powered assistance to Fleet! This initial implementation contains several new features that work with the help of a generative AI via OpenAI API. Fleet is a product where we experiment quite a lot, both with its architecture and UX, and we want to hear your feedback.

Here are the initial AI-backed features that you can try in Fleet 1.19:

1. Inline AI prompt. Just press Cmd+./Ctrl+. or invoke ‘Generate Code’ in any place in any code file and write what you need. Fleet AI will insert its best attempt at the proper code, which you can accept or regenerate.
   
   
2. Generate commit message. Have Fleet AI describe the changes you made, review them, and commit them. Keep your teammates happy!
   
   
3. Explain commit. See a commit with some significant changes you want to know more about? Fleet AI Assistant is good at explaining.
   
   
4. Generate documentation. Whenever you see a piece of code that would benefit from documentation, add it or ask Fleet AI to help.
   
   
5. AI chat. Fleet AI Assistant prefers programming topics and knows quite a bit. Try it! Fleet has added a new AI Chat tool window type and keeps track of your chats so you can return to them later.
   
   
6. Explain code. Code can sometimes be complex at first glance. Fleet can help you wrap your head around it, and you can even learn a trick or two. Select a piece of code and invoke ‘Explain Code’. Fleet will open a new chat window and will give you an explanation there. You can ask additional questions if you need to, and the chat will be saved for future reference.
   
   
7. Assistance in the terminal. Can’t remember the terminal command for something? Open the terminal, hit Cmd+./Ctrl+., and ask the assistant. No need to leave the IDE or read all of the --help.
   
   
8. Copying to the terminal. Whenever Fleet AI Assistant provides a Shell command in its answer in chat, the command can be copied to the terminal with one click. Just press Enter to run the command.
   
   

More features are coming in future updates!

How it works

To make it as easy as possible to try the new features, we are opening preview access to our new JetBrains AI service. It is a facade that transparently connects you, as a product user, to different large language models (LLMs) and enables specific AI-powered features inside many JetBrains products. The JetBrains AI service currently hosts OpenAI and a few models created by JetBrains, with more models planned to be integrated later. Support for IntelliJ-based IDEs and ReSharper is also coming soon.

This approach gives us the flexibility to integrate more models in the future and gives our users access to the best options and models available. The AI-powered functionality appears right inside the tools you are already using and is natively integrated, allowing you to save time and energy accessing features as needed. 

Please note that JetBrains AI service may not be available for everyone immediately. We will let a certain number of users in and once the maximum capacity is reached the rest will be joining the waitlist. We’ll be gradually inviting more people to try the product in the coming weeks.

How we handle your code and data

We understand the importance of transparency in handling your code and data. JetBrains does not read or store your data, nor do we use it to train our models. Here’s how it works: Fleet sends the data to the LLM models and service providers, such as OpenAI, to receive results. In addition to the prompts you type, Fleet may send additional details, such as pieces of your code, file types, frameworks used, and any other information that may be necessary for providing context to the LLM. For more information please read the Terms of Use for the JetBrains AI service and/or our Privacy Policy.

How to try the new AI-powered assistance

Fleet 1.19 will open a dedicated AI Chat tool window after starting. From this tool window you need to log in to the JetBrains AI service. You can log in with your JetBrains Account or create a new account easily. After logging in, you’ll have access to all of the features mentioned above.

Some features are available in the editor and others in various parts of the UI, such as the Git history. Don’t forget that Fleet allows you to find and run many actions in its Actions palette. You’ll also find AI-backed actions like “AI Chats History”. While exploring in Fleet, look for stars ✨, which indicate AI-backed features and actions in the UI.

But wait, there’s more!

We know you are probably excited to try the above features right away, but there are some other important changes included in 1.19 that we want to highlight.

In response to the high number of requests, we’ve added the option to use npm and Node.js run configurations. This update significantly simplifies the process of building a project, running tests, and performing other necessary tasks. Configuring npm or Node.js has become considerably easier.

We received feedback that it was hard to find matching text in the preview when browsing search results. We addressed this problem by adding nice bright highlighting. Now it is much easier to zero in on the most relevant information.

The ability to add rust-analyzer settings to Fleet’s settings.json file was implemented in Fleet 1.19. Add any items described in the rust-analyzer’s manual to your home or project settings.json file to customize the rust-analyzer.

Actions such as renaming, creating folders, copying, and other changes can now be executed on collapsed directory nodes in the project view. We hope this enhancement improves your productivity and streamlines your workflow.

We’ve added new functionality to improve your Python testing experience. With the latest update, you can set a targetType, supporting module descriptors, and paths. Multiple targets are also now supported, enabling you to run tests in specific files or directories more smoothly.

We rolled out an update that makes Python interpreters in settings easily distinguishable. With this improvement, you can quickly identify and manage your Python interpreters at a glance.

This is a big update with a lot of important improvements to Fleet. We hope you like it! See the full release notes for the complete list of changes.

Please report any issues to our issue tracker and stay tuned for upcoming announcements.

To download the update, check your Toolbox App and install version 1.19.

P.S. Plugins support and plugins API is a work in progress. We hope to have news to share with you soon.

JetBrains AI FAQ

1. Will the AI-powered features be available in the IntelliJ-based IDEs and ReSharper?
   Yes. Please stay tuned for updates.
   
2. How much will AI Assistant cost in JetBrains IDEs?
   The AI assistant is currently free to use during the preview phase. We’ll be providing the licensing and pricing model at a later date.
   
3. What LLMs exactly are used by JetBrains AI?
   All third-party service providers and their models are listed on this dedicated page. In addition to this, there are some models created at JetBrains.
   
4. I was put on a waiting list. How soon will I get access?
   We’ll be sure to notify you via email as soon as JetBrains AI is available for you to try. We want to make sure that the service provides a solid experience for our users. In the upcoming months, we will start gradually inviting people from the waitlist. We can’t provide an exact date for when you will gain access.

Join the JetBrains Tech Insights Lab to participate in surveys, interviews, and UX studies. Help us make JetBrains Fleet better!

Join Livestream on YouTube

Or sign up to get an email reminder.

Our guest, Anastasia Birillo, is a JetBrains researcher, Kotlin developer and instructor, an active member of the Kotlin community, and one of the authors of the ‘Programming in Kotlin’ course materials. Anastasia is teaching this course at Constructor University in Bremen, Germany and Neapolis University Pafos, Cyprus. During this livestream, Anastasia will share her teaching experience and the new course materials, designed specifically for Kotlin educators and available for free. You will also have the opportunity to ask questions and get them answered during the Q&A part of the livestream.

The ‘Programming in Kotlin’ course materials include:

 Downloadable slides on the core concepts of Kotlin:

• Introduction to Kotlin
• Object-oriented programming
• Build systems and testing
• Generics
• Containers
• Functional programming
• JVM + the Kotlin compiler
• Parallel and concurrent programming
• Asynchronous programming
• Exceptions
• Testing

Assessment resources for educators:

• Quizzes
• Homework assignments
• Tests

The course covers core topics such as data types, variables and control flow, functions, object-oriented programming, exception handling, collections and generics, lambdas, and higher-order functions. It also covers significant features of Kotlin, including null safety, extension functions, and coroutines. At the end of the course students will study build systems, using Gradle as an example, as well as explore compilation techniques and how the Kotlin K2 compiler works.

This is a comprehensive toolkit for teaching Kotlin and it can be easily customized to align with specific educational needs. 

Join Livestream on YouTube

Or sign up to get an email reminder.

Don’t miss out on this opportunity to access these course materials and launch your very own Kotlin course. Mark your calendars and join us for the livestream!

See you there!

Anastasia Birillo

Anastasia Birillo is a JetBrains researcher and an experienced Kotlin developer who is heavily involved in the Kotlin community. Anastasia has authored the Kotlin Onboarding course from JetBrains and has worked on several projects related to static code analysis and code quality in education for the Hyperskill platform. As a Kotlin expert, she also teaches both basic and advanced Kotlin at Constructor University in Germany and at Neapolis University in Cyprus. Additionally, Anastasia is the main contributor to the Reflekt project, a plugin for the Kotlin compiler that enables compile-time reflection. 

LinkedIn

Twitter

New C# inspections for working with raw strings

Use raw string inspection + quick-fix

Before C# 11, using verbatim strings was the way to go if you wanted to have a multi-line representation. However, doing so meant that you had to sacrifice the regular indentation of your code. You would also have to use two sets of quotes or curly braces in order to avoid confusing them with string delimiters or interpolations.

To improve your code’s readability, ReSharper 2023.2 will suggest transforming these verbatim strings into their raw representations.

Raw string editing context actions

Raw strings have a flexible design that prevents characters from escaping by adjusting the number of quotes, dollar signs, or interpolation braces.

Making these changes manually is tedious, but the latest version of ReSharper can do it for you. In addition to adding or removing quotes and dollar sign symbols, we’ve also added context actions for switching between single-line and multi-line representation.

Simplify raw string inspection + quick-fix

After performing a series of changes on your raw strings, you may end up with a non-optimal string representation where some of the quotes and dollar sign symbols become redundant.

As always, ReSharper offers a new inspection and a corresponding quick-fix to simplify a raw string.

More C# improvements:

• ReSharper 2023.2 EAP 2 introduces new code formatter options, allowing you to align or indent the content inside of raw strings.

• We’ve also improved typing assistance for when you use the Enter, Delete, or Backspace keys.

Gutter marks for recursive calls in C++

If you have a recursive call, ReSharper C++ will mark it in the gutter, making it more visible:

This EAP build also brings support for the .cppm module interface file extension, several improvements for more consistent and straightforward code navigation, and smarter generation of documentation comments. For more details on the ReSharper C++ updates, please see the dedicated blog post.

For the full list of features and improvements included in this build, please see our issue tracker.

That’s it for now!

As always, we’d love to hear your opinions and suggestions in the comments below.

Additionally, we have thought-provoking blog posts discussing the potential threat that AI poses to developers and the importance of studying ML. Finally, don’t forget to explore the list of upcoming conferences scheduled for June!

Stay informed and inspired with our hand-picked collection of Java insights and resources.

Java News

Java News Roundup 1, 2, 3, 4, 5  – These articles bring together the most crucial news from the world of Java. Don’t miss out! 

JavaDoc JDK 20 Updates – Sip of Java – JDK 20 brought several changes to JavaDoc. This article looks at how these changes can help you learn about preview features and make linking easier.

Interpolating Strings Like a King in Java 21 – Inside Java Newscast #47 – Watch this short video to get more familiar with string templates, which help you deal with literal text with embedded expressions and use template processors to produce specialized results.

Java Gets a Boost with String Templates: Simplifying Code and Improving Security – JEP 430, String Templates (Preview), has been promoted from Proposed to Targeted status for JDK 21.

Java Gets a Boost with the Record Pattern, Enabling More Expressive Coding – JEP 440, Record Patterns, has progressed from Proposed to Targeted status for JDK 21. The feature will be fully delivered with improvements based on feedback from previous preview rounds.
JEP proposed to target JDK 21: 452: Key Encapsulation Mechanism API – This JEP introduces an API for key encapsulation mechanisms (KEMs) – an encryption technique for securing symmetric keys using public key cryptography.

Breaking down Barriers: Introducing JDK 21’s Approach to Beginner-Friendly Java Programming – JEP 445, Unnamed Classes and Instance Main Methods (Preview), has been promoted to Targeted status. This feature is designed to make it easier for beginners to write their first programs in Java without needing to understand advanced features.

The SolutionFactory To Java’s Problems – Keynote – Is verbose Java too old school and not fun for modern “kids”? Project Amber aims to modernize the language! In this presentation, you’ll discover how it addresses the existing pain points of Java. 

Quality Outreach Heads-up – JDK 21: Sequenced Collections Incompatibilities – When you use Sequenced Collections, newly created interfaces introduce new default methods which can cause conflicts resulting in source or binary incompatibilities. Read this article to find out what kind of conflicts may arise and how to deal with them. 

State of Java Survey – Azul is conducting a Java user survey until June 15, 2023. If you participate (which takes about 10 minutes), you’ll receive the survey report and have a chance to win prizes like a MacBook Pro or a set of AirPods. Your participation will also contribute to the collective knowledge.

Java Tutorials and Tips

String Templates – Cay Horstman explains how string templates work for Java and shows minor differences in its syntax compared with other languages.  

A Glance At The Java Performance Toolbox – Ana-Maria Mihalceanu demonstrates how JDK tools can help you gain insights into classes and threads and can perform live GC analysis or heap dump post-processing. 

Java Concurrency: Condition – In this article, learn how to make threads wait on specific conditions by using the Condition interface.

The Basis of Virtual Threads: Continuations – Hüseyin Akdoğan turns the spotlight on Continuations, sometimes called “coroutines”, that are the basis of virtual threads.

These notions represent sequential code that may suspend or yield execution at some point by itself and can be resumed by a caller.

Arrays Utility Class – Sip of Java – Take a look at how to efficiently use the Arrays class for handling everyday operations on arrays.

Formatting Inlined @value in Javadocs – Javadoc specifies the details of our methods using special tags. This article studies several new tags that can improve your Javadoc experience.

Creating Scalable OpenAI GPT Applications in Java – In this article and included video, you’ll learn to incorporate the OpenAI GPT engine into your Java projects.

Foojay Podcast #23: Java Profiling and Performance – In this podcast, you’ll gain insights into the challenges of Java profiling, explore various profiling approaches, and discover when and how to use profiling to optimize your code performance.

Unleashing the Power of Lightweight Concurrency: A Comprehensive Guide to Java Virtual Threads (Part 1) – In this article, A N M Bazlur Rahman covers the basics of Java virtual threads, how they work, why they are beneficial for developers, and how they overcome the limitations of traditional Java threads.

OpenJDK – Change the Future of Java – Oracle has created the OpenJDK Developers’ Guide for aligning developers around terminology and processes for participating in the OpenJDK Project. Watch the video to learn how you can contribute to the future of Java.

Avoiding Pitfalls With Java Optional: Common Mistakes and How To Fix Them [Video] – Learn how to avoid traps with Java Optional and use it efficiently to produce readable code.

JavaFinder: Keeping Track of Java Inventories – Gerrit Grunwald shares a simple command-line tool that helps you search for Java distributions installed on your machine.

Patterns: Exhaustiveness, Unconditionality, and Remainder – This article explains how to provide compile-time checking for whether a particular switch is exhaustive for its selector type.

Rolling Binary Trees: A Guide to Common Design Patterns in Java – In this article, George Tanev introduces a linear time algorithm for moving and implementing binary trees in Java.

Languages, Frameworks, Libraries, and Technologies

This Week in Spring 1, 2, 3, 4, 5 – All of the major Spring news from the past month is here. 

Spring Transaction and Connection Management – Vlad Mihalcea explains how Spring handles transaction and database connection management. The covered topics include Spring TransactionInterceptor, read-write and read-only Spring data JPA database connection management, pushing the @Transactional methods further down to data-specific services, and more. 

Spring Tips: go fast with Spring Boot 3.1 – In this edition, Josh Long explores the remarkable efficiencies brought by the latest Spring Boot 3.1 release.

Spring Tips: Go Fast With Spring Boot 3.1 – In this installment, Josh Long looks at how the new Spring Boot 3.1 release delivers incredible efficiencies for developers and machines.

Spring Boot Debugging with Aspect-Oriented Programming (AOP) – Shai Almog demonstrates how to use AOP to debug a Spring Boot application effectively.

Deploying apps with JCEF – How exactly do you deploy an app that uses JCEF? To solve this problem, you can use a sample Conveyor app that is described in more detail in this article. 

How to Backup and Restore a PostgreSQL Database – Discover all of the process stages, from preparing a database to using commands to back up and restore a PostgreSQL database.

Postgres JSON Functions With Hibernate 5 – Take a look at how you can add support for JSON functions in your projects that use Hibernate 5 and Postgres with the posjsonhelper library.

Is Podman a Drop-in Replacement for Docker? – You may have read that Podman is a drop-in replacement for Docker. But is it actually as easy as it sounds? In this blog, you will start with a production-ready Dockerfile and execute Podman commands like you would when using Docker.

Java Developer vs. ChatGPT Part I: Writing a Spring Boot Microservice – Roni Dover describes an experiment where a seasoned Java developer is pitted against the all-knowing generative AI to find out once and for all if an AI can generate a Java microservice end to end. 

Hugging Face Presents HuggingChat, Open Source Alternative to ChatGPT – HuggingChat is a new AI chatbot on Hugging Face that can perform various tasks like article drafting, coding, problem-solving, and answering questions – just like ChatGPT but with a cuter name.

Hibernate default entity sequence – In this article by Vlad Mihalcea, you can find out how the default entity sequence changes when migrating from Hibernate 5 to Hibernate 6. 

Write Once, Run Embedded in any IDE – After creating several Java GUI applications, Anthony Goubard found it interesting to run them within IntelliJ IDEA, Eclipse, and NetBeans. Instead of writing three plugins for each application, he devised a solution described in this article. 

Using Async-Profiler and Jattach Programmatically with AP-Loader – Johannes Bechberger shares his approach to reducing hassle when using async-profiler and jattach. He wrapped async-profiler and jattach in a platform-independent JAR which can be pulled from Maven Central. In this article, he focuses on its programmatic usage.

Building High Performance Microservices for Java with Micronaut & GraalVM – In this video, Bert Beckwith walks you through Micronaut’s support for GraalVM Native Image. You can also take a look at new support for developing portable multi-cloud applications and microservices and preview some of the features in Micronaut 4, including support for records and virtual threads.

The Power of Precise Names: An Example – Is it always bad to have a long method name? Or is it beneficial because it provides precision? Discover the answer in this article.

Getting Started with Eclipse Collections — Part 4 – In this part of the series, Donald Raab explains how to use several of the most commonly used methods to process information in collections.

Kotlin Corner

KotlinConf’23 videos – All of the videos from the recent KotlinConf are live on YouTube! Check out the keynote for all of the announcements! 

TalkingKotlin podcast: Synthesizing a Database with Kotlin – Does synthesizing a database sound like magic to you? In this episode of Talking Kotlin, we discuss how Synthesized.io uses Kotlin together with custom DSLs and OpenAPI to do just that!

Kotlin Coroutines 1.7.0 – The most recent release is here! 

How to implement hexagonal architecture with your Spring Boot application – In this article, Matthias Schenk shows how to implement a hexagonal architecture using Spring Boot with Kotlin.

Functional Error Handling in Kotlin, Part 1: Absent values, Nullables, Options  – Riccardo Cardin focuses on the functional approaches to error handling in Kotlin and introduces the Arrow library. 

How to start with Coroutines in Spring Boot applications – Matthias Schenk describes the very basics when starting to work with Kotlin coroutines in a Spring Boot application for the first time. 

Data Objects in Kotlin – Domen Lanišnik writes about the data objects introduced in Kotlin 1.7.20 and those that are currently planned to be released in version 1.9. You can take a closer look at what they are and what issue they try to solve.

Conferences and Events

Check out the list of upcoming events that may be of interest to you: 

JCON EUROPE 2023 – International Java Community Conference at Cinedom Multiplex Cinema in Cologne, Germany. 

Ignite Summit – Ignite Summit is the premier event for developers who are interested in using Apache Ignite, distributed databases, and in-memory computing to tackle speed and scale challenges.

Culture and Community

Foojay Podcast #22: When Profession and Fun Overlap – In this episode of the Foojay Podcast, volunteers from different organizations explain how coding is used to inspire children to become engineers, or at least, learn to make the most out of the computers and tools around them.

Discovering the Secrets to Success: An Exclusive Interview with Java Champion Michael P. Redlich – Michael P. Redlich, a software developer with over 30 years of experience, highlights the significance of continuous learning, adapting to new technologies, and contributing to open-source projects. He addresses the current challenges faced by developers, including the rapid expansion of cloud computing, and shares entertaining anecdotes from his extensive industry experience.

Why I’m not so Alarmed about AI and Jobs – If you feel like your skills are not strong enough to survive the invasion of AI, this article is for you. 

How to get into ML for a developer? – Is it necessary to start from scratch to become an ML specialist, or can you somehow upgrade your existing knowledge?

Rules of Thumb for Software Development Estimations – In his article, Vadim Kravchenko reveals the honest facts about software estimation. You will discover the importance of estimations, along with the right and wrong methods to approach them.

A Developer Perspective on Developer Experience – Paul Kelly shares examples from real companies that, in his opinion, frustrate developers and make it difficult for them to deliver. He also offers advice, from a developer’s perspective, on how to create an environment that supports innovation.

Google Maps Previews Aerial View API – Google Maps has introduced exciting new features like cinematic videos of points of interest, immersive views for routes, photorealistic 3D tiles, enhanced route customization, and more.

Working on an unfamiliar codebase – It’s common for developers to work on an unfamiliar codebase. Nicolas Fränke describes how he approaches the situation with the help of diagramming.

Tips for Effective Time Management – How can you maximize productivity and achieve your goals in a limited amount of time? Gunter Rotsaert shares his ideas on how to use your time wisely. Create to-do lists, say no to less important tasks, use in-between moments, and get many more tips from this article. 

Decoding Success: An Industry Expert’s Guide to Thriving in Software Development and Security – In this insightful interview, Erik Costlow, Senior Director of Product Management at Azul, provides valuable insights on his transition from engineering to product management, current industry trends, software development challenges, and advice for new programmers.

And Finally…

IntelliJ IDEA 2023.2 EAP Is Open! – We are now ready to provide you with new features and product enhancements in the Early Access Program for v2023.2. 

What’s New in IntelliJ IDEA 2023.1 for Spring Developers – This article highlights the most crucial updates introduced in v.2023.1, including full support for Lombok, reworked Spring tool window, navigation for Spring Security rules, and more. 

How to Work With Protobuf-Maven Projects in IntelliJ IDEA – Protobuf, short for Protocol Buffers, is a language-agnostic data serialization format developed by Google. It is designed to efficiently and reliably serialize structured data to communicate between systems and programming languages. Read this article to learn more about the possibilities of working with Protobuf in IntelliJ IDEA.

Virtual Threads and Structured Concurrency in Java 21 With Loom – Watch this recording of our recent webinar, where José Paumard shows how virtual threads and structured concurrency work.

That’s all for today!

To propose content for the next edition of Java Annotated Monthly, reach out to us via email or Twitter. Keep in mind that articles need to be submitted by June 20.

Lastly, don’t forget that all JAM issues are archived on a dedicated website. So, if you came across an interesting blog but couldn’t read it at the time, don’t fret – you can find it there!

You can get the latest build from our website, the free Toolbox App, or via snaps for Ubuntu.

If you want to catch up on the updates from the previous EAP build, you can refer to this blog post for more details.

Download PyCharm 2023.2 EAP

UX

Text search in Search Everywhere

The Search Everywhere (Double ⇧ / Double Shift) functionality, primarily utilized for searching through files, classes, methods, actions, and settings, now includes text search capabilities similar to Find in Files. With this enhancement, text search results are displayed when there are few or no other search results available for a given query. The feature is enabled by default and can be managed in Settings/Preferences | Advanced Settings | Search Everywhere.

Dedicated syntax highlighting for Python local variables

PyCharm 2023.2 will provide a dedicated syntax highlighting option for local variables. To use it, go to Settings | Editor | Color Scheme | Python and choose Local variables from the list of available options. 

By default, the highlighting is set to inherit values from the Language Defaults identifiers. By unchecking this checkbox, you can choose the highlighting scheme that works best for you. 

Syntax highlighting in inspection descriptions 

In Settings / Preferences | Editor | Inspections, we’ve implemented syntax highlighting for code samples, which facilitates comprehension of any given inspection and its purpose.

Support for Polars DataFrames

PyCharm 2023.2 will allow you to work with a new, blazingly fast DataFrame library written in Rust – Polars. 

In PyCharm, you can work with interactive Polars tables in Jupyter notebooks. In the Python console, you can inspect Polars DataFrames via the View as DataFrame option in the Special Variables list. Both Python and Jupyter debuggers work with Polars as well.  

PyCharm will provide information about the type and dimensions of the tables, complete names and types of the columns, and allow you to use sorting for the tables. 

Note that Polars DataFrames are not supported in Scientific mode.

Please try Polars support and share your feedback with us in the comments section, on Twitter, or in our issue tracker.

Web development

New live templates for Django forms and models

As part of Django support, PyCharm has traditionally provided a list of live templates for Django template files. PyCharm 2023.2 will extend this functionality to Django forms, models, generic views, and admin. Live templates will let you insert common fields for Django views, forms, and models by typing short abbreviations.

You can find the new templates and settings for them in Settings | Editor | Live Templates | Django. To edit the existing templates or create a new one, refer to the PyCharm help page.

The list of live templates that can be used to quickly create Django tags in the template files has also been enlarged. You can find the updated list via Settings | Editor | Live Templates | Django Templates.

Frontend development

Volar support for Vue

We have some great news for those using Vue in PyCharm! We’ve implemented Volar support for Vue to support the changes in TypeScript 5.0. This should provide more accurate error detection, aligned with the Vue compiler. The new integration is still in early development and we would appreciate it if you could give it a try and provide us with any feedback you have.

To set the Vue service to use Volar integration on all TypeScript versions, go to Settings | Languages & Frameworks | TypeScript | Vue. By default, Volar will be used for TypeScript versions 5.0 and higher, and our own implementation will be used for TypeScript versions lower than 5.0.

In the future, we’ll consider enabling the Volar integration by default instead of our own implementation used for Vue and TypeScript.

CSS: Convert color to LCH and OKLCH

In PyCharm 2022.3, we added support for the new CSS color modification functions. This provided PyCharm users with a number of color conversion actions. For instance, you can change RGB to HSL, and vice versa. We are expanding this support in PyCharm 2023.2 to include conversion of LCH and OKLCH with other color functions.

Next.js custom documentation support

Next.js 13.1 now includes a plugin for the TypeScript Language Service specifically for the new app directory. This plugin offers suggestions for configuring pages and layouts, as well as helpful hints for using both Server and Client Components. It also comes with custom documentation, which adds extra information to the output of the TypeScript Language Service. It’s now possible to view this custom documentation in PyCharm.

VCS: GitLab integration

PyCharm 2023.2 EAP 2 introduces initial integration with GitLab, allowing you to work with the Merge Request functionality right from the IDE, streamlining your development workflow. To add your GitLab account go to Settings | Version Control | GitLab.

Notable bug fixes

We fixed the issue with debugging multiprocessing code on MacOS ARM that was caused by a missing dylib file. [PY-48163]

For PowerShell 7, venv is now activated correctly in the Terminal. [PY-58019]

These are the most notable updates for this week. To see the full list of changes in this EAP build, please refer to the release notes.

If you encounter any bugs while working with this build, please submit a report using our issue tracker. If you have any questions or feedback, let us know in the comments below or get in touch with our team on Twitter.

As the complexity of modern software development lifecycles increases, it’s important to have a comprehensive monitoring solution for your continuous integration (CI) pipelines so that you can quickly pinpoint and triage issues, especially when you have a large number of pipelines running.

Datadog now offers deep, end-to-end visibility into your TeamCity builds with the new TeamCity integration for CI Pipeline Visibility, helping you identify bottlenecks in your CI system, track and address performance regressions, and proactively improve the efficiency of your CI system.

Making data-driven decisions to increase the performance and reliability of your pipelines will help you improve end-user experience by allowing your team to push code releases faster and with fewer errors.

In this post, we’ll show you how to:

• Integrate TeamCity with CI Visibility
• Investigate pipeline failures to fix erroneous builds

Integrate TeamCity with CI Visibility

To configure the TeamCity integration with Datadog CI Visibility, first download the Datadog CI plugin on the TeamCity server. Then, ensure that the last build of your build chains is a composite build. Build chains in TeamCity map to pipelines in Datadog, and individual builds map to pipeline executions.

Add the following parameters to your project:

• datadog.ci.api.key: your Datadog API key
• datadog.ci.site: datadoghq.com
• datadog.ci.enabled: true
  

Once you’ve enabled the integration, data from your TeamCity pipelines will automatically flow into Datadog. If you navigate to the Pipelines page, you can see TeamCity pipelines alongside any other providers you may have instrumented with CI Visibility.

Investigate pipeline failures to fix erroneous builds

After you enable the TeamCity integration in CI Visibility, you can use the Pipeline overview page to get a high-level view of the health and performance of your TeamCity build chains, with key metrics such as executions, failure rate, build duration, and more.

Say you’re an engineer at an e-commerce company where one of the checkout services for your primary application is undergoing a major revamp under a tight deadline. After pushing new code, you notice that your builds are extremely slow—much slower than normal. You can go to the Pipelines page in CI Visibility to confirm if your particular pipeline is experiencing high build durations. Then, you can click on the build chain from the Pipeline overview page to investigate the pipeline in more detail.

At the top of this Pipeline Detail view, you can see the status of the last build, with a link to the build chain in TeamCity. Below that are timeseries widgets illustrating the total number of builds, the error rate, build duration, and other key metrics that can help you determine when the build chain began to experience errors. In this case, you see the error rate spiking repeatedly over the past several days.

The Job Summary gives you more granular information about your build chain, such as which specific jobs in this pipeline failed the most, which ones took the longest, and which jobs have experienced performance regressions compared to the previous week. Information like this can help you identify the areas in your CI system where optimization will result in the greatest performance gains.

To investigate further, you can scroll down to see the individual builds for this pipeline. If you click on an execution, you can see a flame graph view that visually breaks down the pipeline execution into the individual jobs that ran sequentially and in parallel.

The flame graph shows you each build’s respective duration broken down by job and, if the build was erroneous, the exact parts of the build that failed. This can help you pinpoint problematic jobs that may be at the root of a failed build.

The Info tab shows you repository and commit information along with other git metadata, so you can easily see the source of each build. To investigate further, you reach out to the team member who pushed the commit for this build and discover that the issue is caused by a typo. (We strongly recommend that customers use a TeamCity username style that contains author email, so that Datadog can automatically detect git author email addresses and correlate commit information to pipeline data.)

Once resolved, the build chain functions without error so you can build and test successfully, and release your updated checkout service to customers on time.

Understand and optimize TeamCity build chain performance

CI Visibility support for TeamCity is now generally available, giving you deep visibility into your build chains so you can troubleshoot failed builds, identify performance regressions faster, and increase your release velocity.

For more information, see the Datadog documentation and blog post on the TeamCity Agent integration.

If you’re new to Datadog, sign up for 14-day free trial.

To support our growing team, offer faster release cycles, develop additional built-in integrations, and provide better and faster support to all of our customers, we have decided to increase prices for both new licenses and renewals of existing licenses of TeamCity On-Premises.

The increase in pricing will affect only TeamCity On-Premises and not TeamCity Cloud, which follows a different licensing model. New prices for TeamCity On-Premises will come into effect on September 1, 2023. You can find both new and current prices on the TeamCity Pricing page.

Renew existing licenses at the current price

Typically, we only permit the renewal of TeamCity On-Premises licenses up to one year in advance. This means that if the maintenance periods of your existing TeamCity Enterprise or TeamCity Build Agent licenses are set to expire within one year from today, you can renew those licenses for an extra year.

However, to help provide our customers with more time to benefit from the current renewal prices, we are introducing a temporary offer. If your TeamCity Enterprise or TeamCity Build Agent licenses have a maintenance window that expires within two years from today, you will be able to renew those licenses for an additional year at the current price. This offer applies to only those orders placed before August 31, 2023.

For example: If the maintenance period of your TeamCity Enterprise or TeamCity Build Agent licenses is valid through April 30, 2024, you have the option to prepay now and extend your licenses at the current rates for an additional two years until April 30, 2026.

While this offer requires an upfront payment, it allows you to renew at the current price for one additional year.

We understand that a price increase is not something any of us like. However, we’ll continue to do our best to minimize these.

We will be reaching out to all of our customers over the next few weeks regarding this update.

Thank you for your support.