We’ll be taking part in GDC 2023 with an in-person booth during the expo days, March 22–24. Here’s what you’ll be able to do if you stop by:

• Visit the Ask for a Demo zone. Our experts will be at the booth and eager to tell you everything you need to know about our products. Drop by and ask any questions you may have about Rider, TeamCity, Space, or YouTrack. On top of that, you’ll have the opportunity to learn useful tips, find out about our future plans, or just chat with our team.
• Try the products you are the most interested in at our self-demo stations. Our experts will be happy to help you learn more about the capabilities and functionality of JetBrains tools.
• Enter our Presentation zone to learn more about game development with JetBrains tools. Each demo talk lasts about 20–30 minutes. We will discuss Rider for Unity and Unreal Engine dev tips, building games with TeamCity, using RiderFlow to better manage your level design, DOTS technology for Unity developers, and more. Check out the topics below and review the schedule at our booth during the event.
• Share your own expertise by participating in a Unity vs. Unreal Engine survey-battle and a Game Development pipeline survey. Fill out a survey to grab some JetBrains swag!
• Want to talk about a potential partnership? Interested in what JetBrains does in general? Stop by our booth and ask any type of question!

The technologies and topics you can learn about at our booth:

• Creating games with Unity. From effective scene management to developing game logic, you’ll learn how to benefit from the brand-new DOTS technology with Rider.
• Creating games with Unreal Engine. Learn how to be more effective with Rider, including tips for working with Blueprints, migrating code from the main game module to a plugin, and much more.
• Creating games with Godot. Find out whether Rider can help you here as well!

• Building a Unity iOS game using TeamCity and AWS. Learn how to build, run, and grow your game with TeamCity and AWS.
• Using JetBrains Space to support your game dev workflow with Git hosting, quality gates, design documents, and more.
• Rider and TeamCity integration with Perforce VCS. We’ll show you how Rider and TeamCity integration works with Perforce VCS. There is no need to use any external utility, since Rider supports it completely.
• Manage projects and tasks with JetBrains YouTrack to make your GameDev truly co-op.

You can find us at the South Hall of the Moscone Center in San Francisco:

See you there,

Your JetBrains team

On October 25–27, we hosted a free virtual event, .NET Days + GameDev Day Online 2022. Thank you to everyone who joined us and watched the talks prepared by the community speakers! Once a year, we invite them to cover topics they’re passionate about and this year we had something new.

In addition to two days full of .NET-related content, we also hosted a third day, completely devoted to game development with a focus on Unity and Unreal Engine.

Here are some fun facts and figures from the event:

• We streamed both events online three days in a row, with more than 22 hours of live streaming overall.
• 6,500+ people registered for the event, and more than 2,700 RSVP’d for all three days!
• We interacted with the chat using polls, giveaways, and more, and we learned a lot about our participants. For example, many of them had ZX Spectrum and Atari 2600 as their first consoles.
• For one of the GameDev Day Online talks, the speakers went beyond mere slides and prepared the entire game.

You can find all the talks as separate videos on our event’s page and in the YouTube playlists:

• .NET Days Online 2022, October 25–26
• GameDev Day Online 2022, October 27

If you have a question for the speakers, you can reach out to them via their Twitter accounts listed on our website and in the description of each talk.

We also want to thank our community sponsors: .NET Foundation, the Kraków .NET Developers Group, ABP Framework, the Belgium Azure User Group, the Boston Unity Group, and the Brisbane .NET User Group.

What do you think about both events? Please share any thoughts you may have in the comments below. Your feedback will help us make next year’s JetBrains .NET Days and GameDev Day Online even better.

The Hackathon in numbers:

• 5 minutes to present
• 4 prize winners
• 48 hours to complete
• 52 projects finished
• 76 projects started
• 200+ participants
• 275+ voters
• $15,000 in prizes

JetBrainers voted to decide the 3 winners, with a prize for the Most Actively Used Project from the previous Hackathon chosen by the organizational team.

This year’s winners are …

Actively Used Hackathon ’21 Project: Gazeta

Hackathons are just the beginning for a lot of the projects, as they go on to be developed into bigger and better things. This year’s Actively Used Project winner is no exception. There’s a lot of work that goes into preparing our weekly internal newsletter at JetBrains. This project provided the means to make newsletters that are informative, engaging, and readable. The project provides the layout of a real newspaper with columns and images, as well as the option to add stories, just like on Instagram. It has been keeping the whole company up to date with all the latest news from inside (and outside) the company.

Third Place: JetStonks

With so many JetBrainers spread across so many offices, international trading among colleagues can be beneficial. JetStonks is an internal exchange and marketplace platform that connects people who want to buy, sell, or exchange things. People who want to exchange something will be automatically matched with people making compatible offers for win-win deals.

JetStonks features a web interface and a bot that will notify users about offers that suit their personal parameters. For instance, JetBrainers living in Berlin can accept offers from JetBrainers based in Munich or Amsterdam, who can send things via delivery.

Second Place: Dino Cup

Did you know it takes 21 days to develop a new habit? Inspired by our JetBrains Summer fest, which saw JetBrainers competing to get active every day of the summer, and by the Duolingo gamification process, the group set out to make a roadmap for building new habits in fitness, self-care, and personal development.

The first 21-day marathon included three tracks of adventure and challenges. Every day participants received 3 tasks in each individual track: Move, Evolve, and Self-Care. The most active users received cool prizes.

First Place: Hospitality

Visiting our different offices around the world is just one of the perks at JetBrains. But where do you stay when you’re abroad? Who can you get to look after your pet fish while you’re away? Hospitality is a service created to help colleagues swap homes and find caring pet sitters among JetBrainers.

There were many other projects at this year’s Hackathon that deserve to be mentioned here, but in keeping with the theme of “Less is more”, we’re going to end the post here. Stay tuned to see what new and innovative direction these projects lead us in!

JetBrains
The Drive to Develop

Arrival

I flew into Porto following Big Data LDN with an easy, direct flight from London. Facing equally long lines to grab a taxi or buy a tram ticket, I opted for the tram, which dropped me off just 15 minutes’ walk from my hotel. However, what I didn’t bargain for is how hilly Porto is, meaning I ended up having quite an adventure dragging my 20 kg suitcase up and down steep, narrow footpaths. I learned my lesson and took a taxi on the way back to the airport!

My hotel was definitely worth the walk, though. The staff were incredibly kind – they even served me a glass of port while I was waiting in reception! With the afternoon free, I headed out to explore Porto’s spectacular old town, Ribeira. I capped off the day with a stop at a bar for some wine and petiscos, Portugal’s version of tapas.

Conference day

As this was their first time running this conference, the organizers sensibly decided to keep it small, running it for one day with two tracks (one for talks and the other for workshops). Despite the size of the event, the attendance was impressive, with around 250 people. It was held at the Computer Sciences department at the University of Porto, which was an ideal venue with a large well-appointed lecture theater for the talks, another large room for the workshops, and plenty of space inside and outside for socializing.

We kicked off with an inspirational keynote from Daniele Procida about what it means to be a developer. This is definitely a talk that I’ll be thinking about for a long time.

Next up, speakers from Holin presented some of the ways they’re using data science to improve the sustainability of cities. I especially loved their research on how to optimize dark corridors for bats to fly around Bristol! One of the things I studied in my undergraduate days was ecology, so this really took me back.

Marcelo Trylesinski, one of the core maintainers of Uvicorn and Starlette, told us the story of how he got involved in both projects. Ashmi Banerjee then showed us some cool tricks for automating things using Python, including a very brave live demo!

In the final part of the afternoon, we got a deep dive into how Python works under the hood from Richard Rowland, and a very funny and insightful talk from Max Kahan about how to rescue a legacy project.

I also gave my talk on how machine learning models understand text by demonstrating a couple of ways you can build a clickbait classifier (using PyCharm, of course!). The audience was great, and I got a bunch of very interesting questions afterwards. I also received a lovely gift consisting of a sampler pack of choice ports, which was very thoughtful and well-suited to the host city!

Following the talks, we had a pizza party at the conference venue, which was a nice chance to catch up with people I hadn’t had a chance to meet yet.

I stayed for a few hours, enjoying the lovely weather and company, before heading off for a nightcap and calling it an evening.

The first PyCon in Portugal was definitely a success. For the size of the conference there were a lot of attendees, and the talks were interesting and high quality. The group was very relaxed and friendly, and was a good mix of developers and data scientists. Next year, the organizers are planning to make it a larger conference in another Portuguese city. Having gotten a taste of how amazing Porto is, I’m looking forward to seeing what else Portugal has to offer in future PyCon Portugals!

• NDC TechTown (August 31 – September 1, 2022)
• Core C++ (September 6–7, 2022)
• CppCon (September 12–16 2022)

NDC TechTown (August 31 – September 1, 2022)

The first stop of my conference marathon was NDC TechTown, an event I had never attended before but heard many good things about from colleagues and friends. This year’s edition had about 300 attendees on site. I really enjoyed the conference venue as well as the location.

Kongsberg is a relatively small town about 1.5 hours by train from the capital Oslo, situated by a river at the entrance to a picturesque green valley, featuring several waterfalls in the city center and great opportunities for hiking, biking, and watersports. The venue was large enough to accommodate the four tracks of content without feeling cramped, and at the same time small enough that it felt cozy and accessible. Everything was organized really well, all the organizers I spoke to were extremely friendly and helpful, and the catering was fantastic, too.

The main conference took place over two days. Kjersti Sandberg kicked off the conference, followed by an opening keynote by Kate Gregory. I am impressed with Kate: every time I see her giving a keynote, she has a brand new talk up her sleeve! For NDC TechTown, she gave a talk about Abstraction Patterns, which I believe will be very useful for many developers.

There were many other interesting talks on Day 1, and with four tracks you always know you will miss most of them. I decided to go to Nico Josuttis’ “C++20 – My Favourite Code Examples” and Vitaly Fanaskov’s “Error Handling in C++”, both of which I very much enjoyed. There were also several interesting exhibitor booths and of course many friends from the C++ community to catch up with. My colleague Anastasia Kazakova was also there – so, even though JetBrains didn’t have a booth this time, at least the CLion team was represented by more than one person!

In the evening, there was the fantastic NDC party. Kyle Kotowick gave a great talk about the Boeing 737 MAX disaster from an engineering perspective, both entertainment and a cautionary tale. Anders Schau Knatten organized an unforgettable C++ Quiz, which my team somehow managed to win, and I learned about some horrifying things about overload resolution in C++ in the process. Overall, it was an amazing evening!

On Day 2, I went to Hana Dusíková’s talk, “Lightning Updates”, which I liked a lot. She showed how to make many different features and vocabulary types of C++20 work together to solve a real-world problem. I was especially happy that I got to see this talk here because I had missed it at CppOnSea earlier this year, which I didn’t attend.

The rest of the day, I was busy with my own talks. I was originally scheduled to give two talks at NDC TechTown, but eventually ended up giving three talks in a row, because some of the other speakers canceled at the last minute, the organizers were looking for speakers on site to fill in the gaps in the program, and I had some material ready to go.

The talks ended at 4:00 pm, so I had the rest of the afternoon/evening to explore the town and go for a run along the shores of the Numedalslågen river. And that was it!

Overall, I really loved NDC TechTown. It’s a conference with a unique twist: there is a focus on C and C++, as well as a (somewhat less pronounced) focus on embedded systems, automotive, aerospace, and similar applications, but other programming languages and other applications are represented, too, so the program and the attendees end up being a really interesting mix. The recordings will be available here.

Core C++ (September 6–7, 2022)

The next stop on my journey took me to Israel, where I was due to speak at the CoreC++ conference, hosted at the Academic College of Tel Aviv-Yaffo, in central Jaffa, an ancient and beautiful port city.

I had been there once before, in 2019, but the conference has grown substantially since then! This year, according to Adi Shavit (one of the organizers), there were 450 attendees on site, which makes CoreC++ the third-largest C++ conference in the world after MeetingC++ and CppCon. Quite remarkable!

The main conference consisted of two days, with three tracks of high-quality content. The opening keynote was delivered by Walter E. Brown. This was a great talk, which ended in a very emotional moment and standing ovations: Walter announced his retirement from speaking at conferences. This was his last conference talk “at least for a while”. Thank you so much, Walter, for everything you have done for C++!

On the first day, after Walter’s keynote, I went to Inbal Levi’s talk “Customization Methods”, which I liked a lot. Inbal gave a great overview of different methods for connecting generic library code with user code, such as ADL, Concepts, CTOs, and tag_invoke. This was followed by an equally interesting talk by Amir Kirsh and Tomer Vromen about the [[likely]] and [[unlikely]] attributes. I learned a lot of surprising facts about them. For example, did you know that they don’t affect branch prediction at all, because modern CPU architectures simply do not have instructions to give hints to the branch predictor? The only thing that these attributes can influence is code layout – but often, that is not going to have the effect that you think it does, and sometimes it will even do the opposite of what you’d expect!

There was also a talk on the new Carbon language by Jon Ross-Perkins, one of the developers of Carbon at Google, followed by many discussions in the “hallway track” about the possible future of this new experimental language. The first day concluded with socializing and lightning talks, which were great as always.

On Day 2, I enjoyed a great talk by Daisy Hollman, a new entry in her “What You Can Learn From Being Too Cute” series. This was the third talk in the series I have seen, and it was my favorite one so far! This one was dedicated to concepts, and all kinds of fascinating, surprising, and terrifying things you can do with them. For example, have you ever thought about what happens if you define the following concept:

template <typename T>
concept True = true;

On the one hand, any type will satisfy the concept; on the other hand, using this on a template is still a constraint, which means it will be considered a closer match than an unconstrained template. This has many surprising consequences. If you want to know more, watch the recording of Daisy’s talk (which will hopefully be released soon)!

Following Daisy’s talk, there were several sessions on coroutines (my favorite was Roi Barkan’s “Coroutine Intuition”, a great, fast-paced overview of the whole topic), my own talk about C++23, and finally David Sankel’s closing keynote, “Rust Features that I Want in C++”. I had already seen this talk at C++Now, it was my favorite talk of the whole conference back there, and I still think it’s a great talk that everyone should watch.

Overall, I really enjoyed this conference. The organizers were great, the attendees were great, the atmosphere was very friendly, there were many great talks, many interesting exhibitor booths, and fantastic catering (a free, delicious buffet lunch every day!). My only gripe is that many talks started 10–20 minutes late, overran, and ended late as a result, so it was very difficult to figure out when to be where. The breaks felt quite short as well: during the afternoon attendees had only 10 minutes to grab a quick coffee and get from one building to the other. I hope the organizers will sort out the schedule for next year, though I’m certainly coming back either way! The recordings will be available here.

After the event was over, there was again some time to decompress. The great thing about Tel Aviv is that the weather is still really hot in September, and the beach is nearby, so I went there with some other attendees for an unforgettable evening of swimming and playing beach volleyball. I really enjoyed the opportunity to spend some time outdoors before traveling to the final stop of my 2022 conference marathon – CppCon, the biggest conference in the C++ calendar.

CppCon (September 12–16 2022)

I was really curious what this year’s CppCon would be like. Before the COVID-19 pandemic, it was a huge event, with about 1,600 attendees in 2019. Then, in 2020, the conference went fully online, and in 2021 it settled on a hybrid format where people could attend both on-site and online, with on-site and online talks and an elaborate online socializing platform. However, in 2021, travel was still highly restricted because of COVID, and so only about 260 people attended in person (I was one of them – here is my trip report).

I was happy to find out that CppCon has recovered significantly compared to last year, winning back its place as the world’s largest international C++ conference: this year, there were about 600 attendees on site, plus about 900 online! This is nowhere near enough to fill the Gaylord Rockies Resort, which is a gigantic venue, but definitely more than enough for a busy and rewarding conference experience.

This year was remarkable for me personally because I had the honor to be invited to give a keynote. CppCon has a very special place in my heart because it is the conference where my career as a conference speaker started (I gave my first ever conference talk here, back in 2015). So delivering a 90-minute plenary session here on the big stage was definitely a very special experience. I gave a talk about how C++23 changes the way we write code, focusing on the four C++23 features I believe are going to be most relevant and impactful for the average C++ developer (deducing this, std::expected, std::mdspan, and std::print). I am happy with how the talk turned out and I believe it was well-received.

CppCon is a full week of content, with many parallel tracks (this year, there were five). So I could not possibly cover everything else I have seen and heard this year in this report, and will instead just list some of the things that seemed most interesting and relevant.

First of all, the big theme of this year’s C++ conference circuit is experimental successor languages to C++. It seems that a lot of people are interested in better syntax, more safety, simplicity, regularity, and reasonable defaults, but do not want to give up interoperability with C++ and jump to Rust, for example. So more and more experimental projects are popping up, aiming to satisfy this need. Earlier this year, Chandler Carruth revealed the Carbon Language project in his keynote at C++North. Now, at CppCon, we learned about two more such projects.

The first is Val, a language being developed by Dave Abrahams (who now works at Adobe) and Dimitri Racordon. Val is remarkable for eschewing reference semantics entirely (a major source of unsafe code in C++) and focusing instead on mutable value semantics. Both Dave and Dimitri gave talks at this year’s CppCon, and Dimitri’s talk actually focused on details about the language itself. While the talk might not be on YouTube yet, here’s the official website of Val with more info and links.

The second is Cpp2, revealed by Herb Sutter in his closing keynote (which is already available online). Herb takes a different approach: his new language is translated by a transpiler, adroitly called CppFront, to C++ code (which he calls Cpp1). This can in turn be consumed by any standard-conforming C++ compiler. During his keynote, Herb did an impressive live demo of how it all works. I published a Twitter thread here summarizing the most important takeaways. And here is the GitHub repo with more info.

There were other fantastic talks this week. Here are a few that I attended and found to be particularly memorable:

• Daniela Engert’s keynote, “Contemporary C++ in Action”, which took us on a journey of building a real-world application combining many different C++20 features and even some C++23 features (such as import std;).
• Erik Rainey’s keynote, “Using C++14 in an Embedded SuperLoop Firmware”, which showed how to use modern C++ in an industry-strength embedded application, in this case the firmware for Amazon’s flying “Prime Air drones”.
• Andreas Weis’ “Deciphering Coroutines – A Visual Approach”, a unique and approachable take on how to teach coroutines, including a brilliant visual cheat sheet.
• And finally, a whole series of three “Back To Basics” talks by Klaus Iglberger, one about value semantics, one about type erasure, and one about the visitor pattern – brilliantly presented educational material useful for beginners and experts alike.

In fact, apart from the popular “Back to Basics” track, there were three more dedicated tracks this year: “Software Design”, “Tooling”, and “Embedded”. And I really like this way of organizing the conference schedule. Kudos to the new program chair Daisy Hollman and the track chairs for putting together such a brilliant program! The recordings are starting to appear here.

I ended up being quite busy all week. Apart from my keynote, I had two other talks to give. I was also invited to sit on the yearly Committee Fireside Chat as well as a panel discussion about concurrency, which were both very rewarding experiences. There were also plenty of other activities, such as the Meet the Presenters Banquet, the Diversity Dinner, two highly entertaining lightning talk sessions moderated by Marshall Clow, and of course endless hallway discussions and after-hours conversations at the bar about C++, the Universe, and everything, catching up with old friends and making new ones. At the end of it all, I was very happy but utterly exhausted and more than ready to go home again.

Overall, I had a really great time at all three conferences. Each one was a great experience in its own unique way. I do have to admit that it was a bit too much non-stop traveling even for my taste. So, even if it means I will miss some great events, I don’t think I will ever do three conferences in a row again!

COUNT ME IN!

Once a year, we invite community speakers to cover topics they are passionate about. The topics include C#, F#, ASP.NET, Blazor, REST, GraphQL, gRPC, stories about contributing to open-source packages, and building microservices. On top of that, we’ll discuss algorithm performance and background tasks in .NET.

In addition to two days full of .NET-related content, this year we also prepared a third day, completely devoted to game development with a focus on Unity and Unreal Engine. We invited six experts from various areas to handle talks and discussions, and share pro tips on how to craft the best games. We’ll cover aspects of performance, UI, and developer habits.

Agenda

October 25, Tuesday – .NET Days

• Maximizing Algorithm Performance in .NET: Levenshtein Distance, by James Turner.
• Let’s Build an Incremental Source Generator With Roslyn, by Stefan Pölz.
• Remote Pairing, by Alain King and Lorraine Steyn.
• ASP.NET Basics for Experts, by Layla Porter.
• Developing Reusable Components for Blazor WASM, by Emanuele Bartolesi.
• Next-Level Console Apps With Spectre.Console, by João Antunes.
• Performance Tricks I Learned From Contributing to Open-Source .NET Packages, by Daniel Marbach.
• Building Microservices With Dapr and .NET, by Cecil Phillip.

October 26, Wednesday – .NET Days

• How to Build a Cloud Native Application With .NET and AWS, by François Bouteruche.
• REST, GraphQL, and gRPC: A Comparison, by Poornima Nayar.
• Message Processing Failed! But What’s the Root Cause? by Laila Bougria.
• Chaos Engineering: Unleash the Monkeys, by Jacob Duijzer.
• Reducing the Environmental Footprint in Nautical Transport With F# & Serverless, by Roman Provazník.
• F# for Performance-Critical Code, by Matthew Crews.
• The Background on Background Tasks in .NET 6, by Scott Sauber.

October 27, Thursday – GameDev Day

• Five Game Developer Habits That Help Software Engineers Reach the Next Level! by Alexander Chatzizacharias and Erik Pronk.
• Making Plugins for Game Engines as a Business, by Alexander Pirogov and Victor Careil.
• Unreal Engine Game Optimization on a Budget, by Tom Looman.
• Unity Packages: From WTF to FTW With Needle Tools, by Felix Herbst.
• Making UIs With C++ in Unreal Engine, by Ben UI.

You can choose whether to attend just a few individual sessions or watch every one of them. Enjoy, and don’t forget to ask the speakers questions!

We’ll stream the presentations live on YouTube, and all the sessions will remain available after the event is over so you can catch up on any you missed.

We also invite other community partners to support our event. You can find more information on how to join as a partner here. This year’s event is supported by the .NET Foundation.

You can also watch videos from the previous years – see the session recordings from 2021, 2020, and 2019.

Check out the full agenda here. See you in October?

C++North grew out of the Toronto C++ User Group, and these local community roots were very noticeable, in a good way. The organizers were clearly proud of being able to host the conference on their home turf. Every morning started with a land acknowledgement, and more than half of attendees were from Canada. A third of attendees were attending their first conference ever.

(photo by Amir Kirsh)

Despite being a new conference, C++ North managed to put together a fantastic line-up. This was a three-day, three-track conference, and the program was packed with amazing talks one after the other. My personal favorites were Kate Gregory’s opening keynote, “Am I a Good Programmer?”, Jason Turner’s “The Power of Compile-Time Resources”, Bryce Adelstein Lelbach’s “C++ Standard Parallelism”, and his other talk “Multidimensional C++” (a great introduction to std::mdspan, a new C++23 feature). For advanced C++ programmers who like to geek out on complex and obscure C++ features, there was Daisy Hollman’s “Cute C++ Tricks Part 2”, continuing the series of talks she started at CppCon 2021. For people who read the ISO C++ standard document and would like to understand it better, Olivier Giroux gave an in-depth talk about forward progress guarantees in concurrent C++ and how exactly they are defined in the standard.

The highlight of the conference was Chandler Carruth’s highly anticipated keynote. He announced Carbon, an “experimental successor language to C++”, which Google and a team of collaborators have been secretly working on for several years now. This keynote is already available to view online and has generated quite a lot of interest in the C++ community. Carbon is still at a relatively early stage of development, so we don’t yet know whether it will be part of the answer to the question “What’s next for C++?”, but it will be exciting to find out. The combination of modern language design choices and full, seamless interoperability with existing C++ code certainly looks like a very interesting package. More details about Carbon are available at their main GitHub repository.

I was also a speaker at C++North myself, premiering a new talk, “C++ Lambda Idioms”. I tried something new: this time I didn’t only have slides, but also some live coding in my talk – in CLion of course. They say you should never do live demos because things will go wrong, but I guess I got lucky, because everything worked perfectly, and it was a lot of fun, too!

Apart from the talks, there were lots of other activities around the conference. There was an unforgettable lightning talk session (with Tony Van Eerd hosting and Guy Davidson singing a sea shanty!), a movie night hosted by Walter E. Brown, a fantastic conference dinner, a board game night, #include event, and even a morning Tai Chi session. The booths were interesting, too. There were some companies that are well-known at C++ conferences, like IncrediBuild and Ubisoft, but also some that I have never heard of before: a company called Groq that makes bespoke chips for real-time AI and HPC, and another one called Hard-Line, which specializes in mining machinery.

Throughout everything happening at the conference, it was very noticeable how much effort the organizers put into making things as inclusive, welcoming, and safe as they possibly could. There was a very friendly team helping people out, and a very visible Code of Conduct team lead. There were gender-neutral bathrooms, a quiet room, and a prayer room. All tracks were captioned by live captioners, and in addition to a screen showing the captioning, there was a caption app that people with hearing difficulties could use on their phones to follow what was being said. There was a meeting room that could be booked, so that nobody had to invite anyone to their hotel room for a business meeting. There was even more: here’s the full list. This level of commitment and attention to detail was truly impressive – I wish every conference did all of these things.

In addition, the venue itself, The Omni King Edward Hotel, was absolutely amazing. This was one of the most luxurious hotels in which I have ever attended a C++ conference. In addition, the venue was fully accessible, in a neighborhood that was safe to walk in, easily reachable on public transport, with food options in any price range all around, and the Lake Ontario waterfront just a short walk away.

Speaking of food, the catering was fantastic, too. This was some of the most delicious food I’ve ever had at a conference. My absolute favorite was the Canadian maple butter tarts. I really hope that they will be back again next year! Of course, they thought about folks with different dietary needs and the menu was accessible online in advance.

In short, I had a great time! I would recommend this conference to anyone interested in C++, and I definitely hope to come back next year!

See also the C++North trip reports by Amir Kirsh, Kareem Skinner, Richard Powell, and Patrice Roy.

The C++Now 2022 edition was held in May. Not that many attendees were present, but luckily the great talks from the event were recorded and will be published for everyone on the conference’s YouTube channel a bit later, but you can already enjoy early access to them now.

As a video sponsor, JetBrains is happy to offer you early access to the C++Now 2022 conference recordings! The talks will be available on a dedicated landing page and will appear there as soon as they are processed by the conference video crew and uploaded, one by one.

WATCH VIDEOS

The page already includes the following talks, among others:

• The keynotes! A Future of Value Semantics and Generic Programming Parts 1 and 2, by Dave Abrahams
• Top 5 Library Additions in C++23, by Jeff Garland
• Customization Methods: Connecting User And Library Code, by Inbal Levi
• Embracing noexcept Operators and Specifiers Safely, by John Lakos

Also, don’t miss this trip report from the conference by Timur Doumler.

Your C++ team
JetBrains
The Drive to Develop

This conference is truly different. It is much smaller than other international C++ conferences. Even pre-pandemic, it was capped to a maximum of 160 attendees, and this year, there was only about half that number, probably due to COVID-related travel hesitancy. As always, there was a good mix of well-known C++ experts and first-timers, and the intimate size of the event provided a unique opportunity for the latter to rub shoulders with the former.

The other thing that makes C++Now truly different is the location. The conference is hosted at the Aspen Center for Physics, with lodging at the adjacent Aspen Meadows Resort. It’s situated in a serene mountain landscape in the middle of the Rocky Mountains, surrounded by snowy peaks, a roaring river, and lots of aspen trees with the characteristic “eyes” from which the nearby resort town got its name. In winter, Aspen is a ski resort for the wealthy, and in summer it is a popular hiking destination. During C++Now, however, in between those seasons, it is mostly abandoned. The Bauhaus-inspired architecture and the many abstract art sculptures scattered around create a strange and otherworldly vibe. The surrounding nature is truly stunning, so this year, I brought along my running shoes and enjoyed some nice runs along the Rio Grande Trail throughout the week.

As always, C++Now kicked off on Sunday evening with an informal reception at the resort bar. The official opening followed on Monday morning with Dave Abrahams’ keynote, A Future of Value Semantics and Generic Programming. After taking a long hiatus from C++ and doing a lot of work on Swift, Dave is now back in the C++ world. He delivered an insightful talk about how generic programming is not template metaprogramming and what value semantics actually means, along with covering important concepts like regularity, independence, object and value representations, and how Swift does this differently from C++. I found it particularly interesting that Swift has no copy constructors, copies can never throw (essentially, all Swift types are trivially copyable), and an out-of-memory error is considered non-recoverable. I also found out that Swift is on Godbolt!

The other talk on Monday that stuck with me was Fedor Pikus’ talk about undefined behavior and how it is related to performance. I really appreciated how he talked us through some assembly output and helped us understand what the compiler does. Apart from the usual UB cases (integer overflow, etc.) he showed many other interesting things: how 32-bit unsigned math is slow on 64-bit systems, how global variables impede a lot of optimizations while const enables them, examples of time travel optimizations, and more. Even before this talk, I had read Fedor’s book, The Art of Writing Efficient Programs, and watched several of his other talks – they are very relevant to some of the work I have done on low-latency and lock-free programming. It was really nice to finally meet him in person, and I definitely had a lot of questions. This is what C++Now is really great for – you get a lot of face time with experts for in-depth technical discussions in between the sessions.

In the afternoon, I gave my own talk about how to implement a lock-free atomic shared_ptr, an updated version of the talk I gave last month at ACCU 2022. Here’s another thing that makes C++Now different from all other C++ conferences: speakers get properly grilled by the audience. There are lots of questions, interruptions, and mid-talk discussions. Fortunately, I was already familiar with this so I knew what to expect. I really appreciate this less formal setup, because I usually learn a lot from these discussions, and my talks benefit greatly from the insights of the experts in the audience. The first talk at C++Now can be quite intimidating for that reason, but no matter how heated the technical debates get, everyone is always very polite and friendly.

Tuesday was another day full of great talks. My day started with Lisa Lippincott’s talk, Principia Mathematica: The Foundations of Arithmetic in C++. This one was refreshingly different. In 90 minutes, she not only developed a complete mathematical framework describing integer math in C++, but she also developed her own dialect of C++ (slightly expanded from the standard C++ language) that is powerful enough to express mathematical proofs.

Afterwards, I went to Bill Hoffman’s talk about how CMake is implementing C++20 modules. Given that JetBrains is a C++ tool vendor, we want to support C++20 modules, and CMake is CLion’s default project model, this was obviously a very relevant topic for me. Bill is actually the CTO of Kitware, the company that makes CMake, so it was really great to learn how it all works under the hood directly from the source. The key piece of tech is the JSON-based format for describing dependencies of source files, currently already supported by both MSVC (released) and GCC (on a branch). This allows CMake to query the compiler for the module dependency graph that it needs to figure out how and in what order to compile the modularized C++ source files, instead of doing it themselves (which requires parsing C++).

Finally, I went to David Sankel’s talk, Rust Features that I want in C++. For me, this was the talk of the conference. David started by talking about features like Rust enums, language variants, the very powerful pattern matching facilities, and how work on pattern matching proposals in C++ appears to have stalled. Then, he showed some examples of Rust’s powerful metaprogramming and Rust libraries, like Rocket, built on top of that, which are amazing and unthinkable in today’s C++! My favorite part was when David talked about how Rust was designed around inclusivity and beginner-friendly ergonomics from the start, how those ideas are a core part of the Rust culture, and how it shows in practice through clear and helpful error messages, beginner-friendly APIs, and so on. This sounds very much like a world I’d like to live in! I’m not ready yet to throw in the towel on C++ and switch to Rust (although it is tempting!), but I hope that we can learn from the Rust community and make the C++ experience more inclusive and approachable.

On Wednesday I woke up to find everything covered in snow. One feature of C++Now is that the weather never gets boring – one day you can have a snowstorm so severe that planes cannot land and are forced to turn around, and the next day it’s sunny and baking hot. The conference is set up so that the talks happen indoors, but a lot of the socializing happens outdoors, so it’s important to remember the saying, “There’s no such thing as bad weather – only bad clothes!”

Fortunately, I was prepared and I enjoyed another wonderful conference day. I chose to attend another talk about integer arithmetics, this time by Andreas Weis, who went into a lot of detail on how it is actually implemented in hardware. Interestingly, it turns out that with today’s 2’s complement machines, signed integer overflow doesn’t necessarily need to be UB because it is well-defined on the hardware level, but compilers treat it as UB because the optimizations it enables are very dear to us.

After that, I went to a really interesting talk by Michael Caisse about implementing message handling on embedded platforms in modern C++ using a very elegant, declarative approach. This was followed by a session led by Bret Brown and Daniel Ruoso, Searching for Convergence in C++ Package Management. The lack of a universally accepted build system and package manager is one of the biggest pain points of the C++ community, and despite many very smart people trying to solve this problem, we are still not there yet. I wouldn’t say that the approach presented in this session constituted any particular breakthrough (their approach is, at least initially, focused on Linux and pkg-config and therefore not relevant for large parts of the community), but the discussion was certainly very interesting. This issue is especially difficult because build systems and package managers are completely outside of the scope of the ISO C++ standard, which only defines the core language and the standard library, so it’s not even clear what the right platform is to discuss these things. The standard committee has a study group for tooling (SG15), but it is not clear to me yet what exactly this group can do beyond perhaps giving some recommendations.

Besides all of the talks, there was a lot more going on. There were two evening sessions with informal 5-minute lightning talks moderated by Michael Caisse that were full of highly entertaining contributions. There were the hands-on “Library In a Week” coding sessions every morning, led by standard library veterans Marshall Clow and Jeff Garland. We also had sessions regarding conference planning for C++Now 2023, further developing the conference format and organization. Of course, there are all the conversations in between, usually called the “Hallway track”, although here it would be more accurate to call it the “meadows-surrounded-by-snowy-mountains track”. As always, I had many CLion users asking me things. This time, I had conversations about C++ modules, various cool features of the CLion debugger, and CLion’s disassembly view. Unfortunately, it currently only works in situations where the source code is unavailable, but if you’d like that to change you can upvote the appropriate ticket!

On Thursday, Phil Nash did a double session (3 hours in total!) on C++ Coroutines From Scratch. He took an approach I haven’t seen before: he started by talking us through a relatively large real-world C++ example, which he then re-wrote using coroutines. The plumbing and implicit compiler magic that happens to make coroutines work was then explained along the way. I really enjoyed this session. Phil’s material and the technical discussions that happened during the session certainly helped me fill in some remaining blanks about how C++20 coroutines work. At the same time, I do not think that someone who has never heard about C++20 coroutines before would have grasped them from this talk alone, and that’s true for every other coroutine talk I have heard so far. There is something about them that makes the learning curve especially steep. If you want to get into C++20 coroutines by watching talks, I recommend watching multiple talks approaching it from different angles. Start with Adi Shavit’s Generators, Coroutines and Other Brain Unrolling Sweetness and the coroutines section of my own How C++20 Changes The Way We Write Code for a high-level introduction, then watch Pavel Novikov’s Understanding Coroutines by Example to dive deeper, and finish off with Andreas Weis’ coroutines talk from ACCU 2022 and this talk by Phil Nash (we’re waiting for videos of those to be released!) to see more use cases. After having seen all these coroutine introduction talks, I feel very tempted to prepare a more in-depth coroutine tutorial myself!

The other session I visited on Thursday was Sean Parent’s Exception Handling the Other Way Around, which was full of good stuff: a nice refresher on preconditions, postconditions, and invariants, a very interesting definition of “safe” code, a discussion on contracts, and useful guidelines on how to write code that is exception-safe by default.

Friday was a short day for me. In the morning, I attended a talk by Eduardo Madrid, where I learned about cache-friendly binary search, Robin Hood hashmaps, the SWAR trick, and lots of other techniques to squeeze maximum performance out of associative data structures. And then there was Sean Baxter’s closing keynote about Circle and how it makes metaprogramming much better and more elegant… except that sadly, I had to miss the whole keynote, because there was a C++ committee teleconference going on at the same time. Three of my own proposals (P1774, P1839, and P2582) had to go through a round of Core wording review that I could not postpone, as the deadline to get wording for any new features into the C++23 working draft is only two months away.

Friday afternoon was quiet as always, with no talks happening. People went for a hike in the mountains, a workout in the gym, or simply to relax in the sun. I went for a 10-mile run along the Roaring Fork River, followed by a visit to the Aspen Meadows Resort’s heated outdoor pool, my favorite place in Aspen for enjoying a view of the stunning snowy mountain peaks. Unsurprisingly, I was not the only C++Now attendee who opted for the pool, so the conversations about C++, CLion, the Universe, and Everything continued there.

And then it was already time to say goodbye and go home. As always, C++Now was such a great experience that I was sad to leave. I hope to be back next year! I strongly recommend attending this special conference at least once to anyone interested in modern C++. It is a truly unique experience.

For me, ACCU has a special place in the C++ calendar for many reasons. First, ACCU is known for its exceptionally friendly and nice community, including folks who have been attending ACCU regularly for a decade or more, but also being especially welcoming and approachable to first-timers. This year was no different – it was great to be back meeting old friends and making new ones.

ACCU is also special in that it is not only about C++ (although it has a large proportion of C++ content), so you also get content on other technologies and non-technical talks about soft skills and other interesting things. The quality of the talks is very high and the size is just right: bigger than “small” conferences like C++Now, but not as big as CppCon or MeetingC++, so you still get the chance to meet and talk to most attendees.

In pre-pandemic times, I would usually expect about 400 people at ACCU. This year however, we only had about 150 people on site, so it was noticeably quieter than usual (although the vibe was as positive as ever). In addition, there were about as many people attending online, as the conference was fully hybrid this time, with three on-site and two online tracks and the option for online attendees to watch the on-site talks and ask questions.

The organizers went to great lengths to make the online component of the conference really enjoyable, including recreating the whole conference venue (Bristol Marriott) online inside gather.town. But I have to admit that I did not engage with the online component. Why spend time in video chat rooms when you are on site at the venue and have real people to interact with? Therefore, the following trip report is focusing exclusively on the on-site component of the conference.

Not only were there fewer people on-site, but also fewer booths. I spotted the traditionally present Bloomberg booth, as well as Graphcore and SonarSource booths. And we had a #include table again, which was a very popular hangout spot. Sadly, JetBrains did not have a booth this time, as the rest of my team was unfortunately unable to attend. In fact, out of all of the ACCU conferences I’ve attended, this was the first one with no JetBrains booth! One of my most memorable conference experiences was walking up to the JetBrains booth at ACCU 2017 and asking them whether they would consider hiring me, and the following year I was working behind the very same booth. I very much hope we will be back there in full strength next year, but this time I was representing JetBrains on my own.

Conference day 1 started with Guy Davidson’s keynote “Growing Better Programmers”. Guy is a good friend of mine and this was his first proper conference keynote. I have to say he did an amazing job! Speaking from many years of experience, Guy shared many great thoughts about mentoring and supporting programmers, promoting good practices, conducting helpful code reviews, being a good manager, and much more.

I missed the talks following the keynote because I was busy practicing my own talk, how to implement a lock-free atomic shared_ptr, which I presented that afternoon. Following that, I was met with the usual dilemma at such conferences: there are multiple tracks and you can only go to one. The program is so high-quality that you end up missing a lot of fantastic talks you really want to see. My talk of choice was “Zen and the Art of Code Lifecycle Maintenance”, a very deep and insightful investigation of what we actually mean by “code quality.” The talk was given by Phil Nash, my predecessor as C++ Developer Advocate at JetBrains, who now works at SonarSource.

My first day at ACCU 2022 wrapped up with a lightning talk session moderated by Pete Goodliffe. This is the true highlight of the ACCU conference: the lightning talks are usually very entertaining, creative, funny, thoughtful, and mostly not about programming at all. In between the talks, Pete tells dad jokes, and if any speaker overshoots their 5 minute speaking limit, Pete takes away the microphone mid-sentence and pushes them off the stage. It’s hilarious!

Day 2 opened with a keynote by Hannah Dee, “Diversity Is Too Important to Be Left to Women”. I was really impressed by this talk. It covered why diversity and inclusion are important, what we should do, and what we should not do, and covered it all in a way that felt extremely well-researched and backed up by data and facts. Even though this issue was already very close to my heart before Hannah’s talk, I learned about so many new things from her, like the concepts of gender role spillover and stereotype threat, how self-efficacy affects performance, the Petrie multiplier (a very simple yet powerful mathematical model), pareidolia, and more. I highly recommend this talk as a solid, approachable, and enjoyable introduction to anyone interested in the topic of diversity in tech.

Switching gears after the keynote and diving into C++ code again, I went to “C++20 – My Favourite Code Examples” by Nico Josuttis. This talk was full of interesting C++20 code. Nico started by showing various ways to use C++20 concepts and constraints in practice. Among other things, I learned that we can use a requires-clause inside an if constexpr, like this:

void add(auto& coll, const auto& val)
{
 if constexpr (requires { coll.push_back(val); })
   coll.push_back(val);
 else
   coll.insert(val);
}

This is a very convenient way to branch on the existence of a member function, something that was a lot more cumbersome pre-C++20. Nico then showed practical examples of how to use ranges, views, the spaceship operator, and other C++20 features all working together. Along the way, I also learned how to implement your own range sentinel! Of course, it would not be a Nico Josuttis talk without a healthy dose of ranting about things that the C++ standard committee has gotten wrong in Nico’s opinion: how cbegin is utterly broken, how “forwarding reference” is a bad name, how std::views::elements<0> does not work for user-defined types unless you declare your own tuple customization points before you #include <ranges> (which is quite unfortunate indeed), and so on.

ACCU is one of the conferences that offer talk slots to sponsors, but often these can be very interesting, so I went to a sponsored session during the lunch break: “The Power of Clean Code” by the SonarSource folks. I was very happy to see CLion in action there, supplemented by their SonarLint plug-in, which looks like a very powerful tool that I definitely need to check out in more detail.

After lunch, another ACCU speciality was waiting. The normal talk length is 90 minutes, but they also have 20-minute “quick talks”, usually several of them back to back. The ones I chose were very interesting and relevant explorations of “soft” topics: a talk by Björn Fahller about burnout, a talk by Dom Davis about remote working, and a talk by Joe Pascoe about how to be a good manager.

The second day finished with another round of lightning talks, followed by the C++ Pub Quiz hosted by conference chair Felix Petriconi.

Day 3 started with a keynote by Patricia Aas about software vulnerabilities, and this was another absolute highlight of the conference. Patricia took us on a fascinating time travel journey through the last two decades. Her slides were packed with interesting code examples demonstrating vulnerabilities arising from malloc, use after free, heap buffer overflow, integer operations, and printf format strings. Among other things, I learned what a “Write-What-Where primitive” is and that format strings are an almost Turing-complete programming language! Patricia’s talk ended with the thought that we would all benefit from more cross-pollination between the systems programming community, which C++ is part of, and the binary exploitation/vulnerability community.

The next talk slot had no fewer than three coroutines-related talks scheduled against each other. I decided to listen to Björn Fahller’s talk about using coroutines for asynchronous I/O on Linux and how they really help to avoid callback hell. In C++20, we got a basic low-level API with hooks into the compiler that enable the use of coroutines, but no library facilities whatsoever on top of that to actually use them. So even for the most basic coroutine example, we need to write a lot of boilerplate code by hand – the coroutine type, the promise type, and so on. This is very hard to learn and to teach, but Björn did a good job guiding the audience through the required machinery. His talk also contained references to other helpful introductory talks about C++20 coroutines, such as Pavel Novikov’s “Understanding Coroutines by Example”.

The other highlights of Day 3 for me were Kate Gregory’s “Abstraction patterns” and another talk about coroutines, this time by Andreas Weis, showing how to use them for data processing pipelines (reading a file from the disk, compressing it, and so on). With my background in audio software development, I was fascinated by how Andreas’ data pipelines were structurally virtually identical to audio processing graphs, containing sources, sinks, filters, and buffers, with data channels exchanged in between them. This makes me think (again!) that coroutines would probably be very useful in that domain, too.

In the evening, there was a third lightning talk session hosted by Pete (they were so popular this year that Pete ran out of lightning talk slots!), which was just as much fun as the others, and finally the traditional conference dinner, which I always enjoy. The ACCU conference dinner is geared towards enabling as many conference attendees as possible to mingle with speakers. Speakers remain at the same table throughout the dinner, while everyone else changes tables after every course. This is good fun and you get to meet lots of new people. In addition, there is always a theme – this year it was film.

And now we’re at the last day of ACCU! I started the morning by attending Mathieu Ropert’s “Basics of profiling”. Mathieu delivered a really good beginner-friendly introduction to profiling, why it’s important, things you need to know such as sampling profiling vs. instrumentation profiling, and more. He then actually live-demoed profiling his video game Hearts of Iron IV with the Optick Profiler, a instrumentation profiler, and Intel VTune, a very powerful sampling profiler. He explained what to look for and how to interpret what you see, and finished off his talk with useful general tips on how to optimize a C++ program. This hands-on approach including live demoing is rarely seen in conference talks, and I really enjoyed it.

Later that day I attended John McFarlane’s talk “Contractual Disappointment in C++”, which I also highly recommend. The title would suggest that the talk was about contracts in standard C++ and how we ended up not having them, but actually it was not about that at all. Instead, John talked about contracts as a programming concept, the difference between bugs and errors, different types of contracts, and other things that every programmer should think about.

Finally, it was time for the last talk of the conference: Titus Winters’ closing keynote! Titus, the author of “Software engineering at Google,” aka the Flamingo Book, decided to fully embrace his new brand and showed up on stage in a flamingo shirt. His keynote titled “Tradeoffs in the Software Workflow” was just as high-quality and thought-provoking as I had hoped and tackled really big questions for our industry such as “What is the value of the code that you write?” and “What is the value of preventing a defect?”. This is another talk that I highly recommend. In fact, all the talks I saw this year were so good that I am very impressed once again by the quality of the ACCU conference program.

Of course, in between all the talks, there was the all-important hallway track. Even though there was no JetBrains booth this time, I was still very busy talking to people about JetBrains products in general and CLion in particular. Some noteworthy interactions involved helping a CLion user figure out how to build the LLVM project in CLion (which gave me some good ideas for putting together a “CMake in CLion” tutorial) and multiple folks asking about the new “thin client” remote development mode in CLion (which is currently still in Beta, but nevertheless already very usable, so I recommend you check it out now!).

And that was it from ACCU 2022! I am really looking forward to next year’s conference, but in the meantime, I will be attending other in-person C++ events, with the next one on the calendar being C++Now in beautiful Aspen, Colorado. See you there!

All individual talks are now available on demand, along with the recording of the whole event. Watch them at your own leisure, and feel free to share them with your friends and colleagues.

What’s New in TeamCity 2021.1 & 2021.2 by Alexander Rassokhin

Alex goes over the whole list of improvements introduced in 2021 and talks about some of the most important new features in more detail.

TeamCity Cloud – Getting Started by Marco Behler

This talk is an overview of TeamCity Cloud. Marco starts off with the very basics, such as registering a TeamCity Cloud account, inviting collaborators, and running a first build in a brand-new cloud instance. He then goes on to cover cloud agents, the software they have installed by default, and how you can host them yourself.

CI for Unity Games Using TeamCity by Daniel Gallo

Many game developers use TeamCity to manage their build pipelines. In this session, Daniel walks you through the configuration of a Unity build pipeline in TeamCity and shows how a Unity game can be seamlessly built for various platforms.

Beyond Configurations – Integrations to Supercharge Your CI by David Stewart

TeamCity offers a number of integrations with third-party development tools. In this talk, David explores Cloud Profiles for on-demand build agent generation. He also discusses adding third-party reports to your build results page and working with the TeamCity IDE plugins to run personal builds for your projects.

How Development Teams Can Benefit From Working With Tests in a CI/CD by Evgeny Bovykin

In this talk, Evgeny showcases everything you need to know about working with tests in TeamCity. This includes best practices for working with test coverage, investigations, test history, and more. The demo is shown using a live TeamCity instance, and all configs will be shared so that you can replicate the setup on your own.

And for those interested in reliving the full live event experience, here is the recording of it, hosted by Marco Behler and Yegor Naumov:

At JetBrains we are focused on the developer experience (DX), so we came up with an idea to hold a series of meetups with like-minded experts around the world. We’d like to cover topics like development tools (IDEs, VCS, Code Review, and Automation), build tools, and CI/CD. If you’re as passionate about DX as we are and want to discuss these things and others, please join our Slack community here and share your experience, questions, and problems. All of the information about future meetups will be posted there.

First Meetup

Our first online meeting will be on December 20th at 5pm UTC/ 6pm CET / 9am PST. 

Add to Calendar: Google, Apple/Outlook

You can join the live stream on YouTube. Don’t forget to use the “Set Reminder” button to get a notification before the event so you don’t miss it. 

Let me introduce our speakers and their topics:

Krzysztof Romanowski from VirtusLab. He leads the Scala 3 team and has been involved with developer tooling for over 8 years.

When to hack and when to stop: lessons from the life of a ToolOps engineer.

“Finding the right balance between quality and getting things done defines an experienced developer. In other words, senior developers should know when to hack and when to stop (and to do things properly).

In this talk, I will share stories from projects I have worked on over the years and show whether my tricks paid off or were a constant source of problems. I will also discuss projects where a proper hack was the only way.”

Yan Zhulanow and Nikita Bobko from JetBrains. Both are developers on the Kotlin IDE plugin team.

From one monorepo to another: The story of Kotlin IDE plugin migration.

“This talk is about the migration of the Kotlin IDE plugin from one monorepo to another. Historically, the plugin had always been a part of the compiler repository. Some time ago, it became clear that moving the codebase closer to IntelliJ IDEA could make development a lot easier.

So a year and a half ago, we initiated the migration process, and it was a tough journey. As you can imagine, it wasn’t simply about moving the source files from one Git repository to another. We had to migrate from Gradle to IntelliJ Platform’s build system and improve our test infrastructure. Even after the migration, we had to keep up with both the Kotlin and IntelliJ Platform release cycles. It turned out to be the most challenging part of the story.

We will cover the technical problems we had during the migration, the solutions we chose for them, and how we managed to keep developing and releasing the product during such an infrastructure leap.”

How to Join

It’s simple – you can join us on Slack. Streaming links for future event announcements will be published there. We hope that it will be a good place for communicating with other like-minded community members. Also you can join the live stream on YouTube.

Your JetBrains Team

The Drive to Develop