CppCast - Tipi.build

Episode Date: July 8, 2021

Rob and Jason are joined by Damien Buhl and Yannic Staudt from tipi.build. They first talk about a new text encoding library and whether const should be the default for variables. Then they talk about tipi.build, the Compiler-as-a-Service that understands C++ code and can build it without scripts. News Any Encoding, Ever - ztd.text and Unicode for C++ Should every variable be const by default? Reversing words of a string with ranges -#thatsarotate Links tipi.build Join tipi.build beta tipi.build blog @TipiBuild Sponsors PVS-Studio. Write #cppcast in the message field on the download page and get one month license Date Processing Attracts Bugs or 77 Defects in Qt 6 COVID-19 Research and Uninitialized Variables

Episode 307 of CppCast with guest Damian Buhl and Yannick Stout recorded July 7th, 2021. Sponsor of this episode of CppCast is the PVS Studio team. The team promotes regular usage of static code analysis and the PVS Studio static analysis tool. In this episode, we talk about a new text encoding library. Then we talk to Damian and Yannick from TPBuild. Damian and Yannick talk to us about TP Build, a C++ developers by C++ developers. I'm your host, Rob Irving, joined by my co-host, Jason Turner. Jason, how are you doing today? I'm all right, Rob. How are you doing?

Doing okay. Just a couple days after the long 4th of July weekend. How'd that go for you? Oh, it's still going from my perspective. Still going? Like fireworks still going off in the background or stuff like that? Yeah, about one or two a night to go off, which is exactly enough to now have my dog be afraid of dusk. So she'll just sit there and just start shaking at like six o'clock, and it's hard to get her to eat dinner and stuff even if nothing is happening and i'm like okay well maybe my dog's just crazy

but i just happened to meet a neighbor who was walking past and he said yeah the people behind him have been setting off fireworks every night for a week and his dog refuses to go outside after seven o'clock no matter what's going on poor puppy that. That's sad. Yeah, I don't think we've been, I haven't noticed any in the evening the last few nights, but I think a lot of people, they're illegal to get the really big ones in North Carolina. They are here too, yeah. But you can cross over the border into South Carolina and get really big ones,

and I think a couple of my neighbors kind of went all out, and there was quite a lot going off on the 4th. Yeah, for us, they drive up to wyoming to get them same idea yeah okay well at the top of every episode like through the piece of feedback uh this week we got a tweet from matt price saying when the pandemic started i was caught up on cpp cast then without my commute i got way behind and i'm only three and a half months behind uh thanks to jason and rob for keeping up the good work and yeah we're happy to keep this going we we didn't want to uh miss out you know there's no real excuse to be missing out over the past year year and a half whatever it was

yeah and if you are just now getting back to commuting or something like that then you probably do have a pretty good uh backlog catch up on. Yeah, definitely. Because it's what I think the average person probably has been working from home for 15 months now. Yeah, from our listening group. Yeah, something like that. Okay, well, we'd love to hear your thoughts about the show. You can always reach out to us on Facebook, Twitter, or email us at feedback at cppcast.com.

And don't forget to leave us a review on iTunes or subscribe on YouTube. Joining us today is Damian Buhl. Damian is the co-founder and CEO of Tippi Build. He's an enthusiastic C++ developer, open source entrepreneur, CppCon speaker, game maker, community founder, Qt for Android contributor, Boost Fusion maintainer since 2014, and Yannick Stout.

Yannick is co-founder and COO of TippiBuild. As an embed engineer and polyglot software developer, he develops many products from end to end and is currently busy building large parts of the front end of TippiBuild, continuously perfecting his practice of coffee-driven business development. Welcome both of you to the show. Hey, thank you very much. Hi, Robert. Thanks for having us.

Coffee-driven development, that's us. A coffee-driven development that's kind of like test-driven development? Yeah, I'm perfectly my coffee addiction. I need them to run and I took it to quite a high level

in terms of quality the last few years. Too high. We cannot have a good coffee machine at the office it's never good enough you know like for yannick well that probably just got compounded by the fact that you've been working from home right now you you probably have your own espresso machine and you tamp it down and hand grind it with like i i had that for a few years, but indeed, last February, I think I upgraded because the old one broke. And I went full out with the support of my wife, who I kind of co-addicted her in the last few years.

And yeah, she tagged along and this time she agreed to spend the right kind of money. I'm almost afraid, but I still want to ask, what is the right kind of money for a good coffee maker? Let's say you go, really good stuff starts at about $800, euros, whatever currency. And in this case, like counting the meal and accessories etc i think i run about at 3k something like that so it's a hobby so yes it's definitely a hobby at that point yeah i don't i don't tolerate a lot of caffeine very well but whenever i am traveling to europe and they have one of the automated espresso machines where I can just press a button and it like does all the things, I totally have like two or three cups a day of whatever. Right. But then I just learned from someone that some of those machines go to the point of like playing a wave file of a grinder so that you think that it's fresh grinding the beans.

And some of them actually fresh grinding the beans and some of them actually fresh grind the beans yeah so so that's the big vending machine there are some that do fake it uh mainly for uh for clean cleanliness reasons because uh the coffee always is so uh so they they have kind of portioned stuff inside and uh the good impression that, yeah, you're getting something fresh. Indeed, they do play something. I know that quite in detail because I had the opportunity to work with a such a vending machine maker a few years back. And so, yes, it's a thing,

but not on the kind of small desktop size home machines. Right, okay. He even goes so far that he implemented in the TP Build backend the HTC PCP protocol that is an RFC from 1st April which is like the hypertext coffee pot control protocol. Yes, exactly. If you get the 418, I'm not a teapot.

It's Yannick. It was somewhere behind there. Funny. Okay. Well, we have a couple news articles to discuss. Feel free to comment on either of these, any of these, Yannick and Damien. And we'll start talking more about tippy builds,

okay? Okay. Okay. So this first one, we have a post on John Hede Monead's blog, and this is Any Encoding Ever? ZTD Text and Unicode for C++. And obviously we've had John Hede Monead on before a couple times, and he's been talking about Unicode and text for a while now. obviously we've had John he'd meet on before a couple of times and he's been, you know, talking about, uh,

Unicode and text, uh, for a while now, I think it's been a bit of an obsession for him. And, uh, he, you know,

seems to have done what he's been seeking out to do with this, uh, post and, and with this library, it looks like a lot of work. Yeah. Yeah. He's saying you can,

you know, encode decode from, from one encoding to another, and even add support for other encodings that maybe you care about that no one else would care about. That's pretty huge, actually. Because until now, there was only LibICU, I would say, that was really capable of doing this kind of stuff, if I'm not mistaken. And this was really missing to have such a library. I really like the fact that we finally have like a real iterator on smileys or on emojis because until now you couldn't iterate easily on emojis.

It was hard. Yeah, I mean, there's a lot of things that can go wrong in that time. I mean, junior steps, it's kind of like the first thing they learn is hard to master, like encoding, especially on system boundaries, like across protocols and network. There's so much to go wrong. Yeah, and I... Oh, sorry, go ahead, Damien. I thought in the article, it was really like a pushing, like, uh, that he is angry against,

uh, not being able to do Unicode properly and so on, but he decided to, to show his middle finger or something like this. It was a really energetic, uh, energetic article. Like, uh, when you, when you read it at the morning, in the morning, you're, you wake up. That's like a good cup of coffee. Yeah, exactly. It's funny because I was reading this

and I'm like getting about halfway through and I'm like, you know, I know so many people who are concerned about the state of Unicode and the C++ standard. I'm surprised this article didn't come from someone that I knew because I didn't actually look at the URL, right? And then I get halfway through it and I'm like,

I gave a presentation about this. I'm like, I gave a presentation about this. I'm like, that's john heed. Wait a minute. Oh, like, it all makes sense now. Yeah. Okay. Next, we have this post on blay cpp.com. and it's should every variable be const by default and uh yeah const certainly important in civil souls language i think it would be a huge change to uh go to const by default but um certainly an interesting article i didn't realize i don't think that um that was actually the way that russ did it with having to declare a variable as mutable. Mutt. Mutt, yeah. I find it slightly annoying that it's mutt, but whatever.

Do you feel like it should be just mutable spelled out? I think it should just be mutable, yeah. But, you know, whatever. That's a randomness. But Jason, you are more like constexpr, the things, right? No, not const, the thing. You're right, constexpr should be your default. If you can't do that, then const. And then if you can't do that, then fine. You're allowed

to make a value mutable. I find it really interesting. I also try to do that, to have const everywhere, but in some places where you do just copy, I think it's a bit overkill to const everything when you just just copy, I think it's a bit overkill to const everything when you just have copy arguments.

But it makes me remember a talk at CppCon 2017, I think. There was a library named Ema, and the author implemented a notepad based on this library that he named Evic. And this was about immutability and the fact that everything is immutable, you can make better parallel computation because you don't need to do locking when you change stuff. And you can even like do a flyweight pattern that works really well because you never remove anything from memory so long as you just fill it up but because you come back to states that already existed before you are not like growing infinitely and I found it really interesting back then and I think it is somewhat related in the sense that you get better of parallelism and so on. I don't know what you think about it.

It was that, who was the speaker for that talk? For Emer and Evic, this was, if I'm not... Someone I can picture, but I can't remember their name. Wondering if that's who it was. If I find the purpose of the slides, 1P... Yeah, okay, 1P.

Okay, yeah, yeah, yeah. Postmodern immutable data structures. Really cool talk, I think, and really great work there. Yeah. Can I just make one nitpicky comment about this article, though? Sure.

I'm sorry, but it bothered me because it happened twice, but they refer to const as a four-letter word. Yeah. I noticed that, too. Yeah, I don't know why. Off by one errors. That's the hardest problem in computer science, right? Right, right.

Okay, and then the last thing we have is a blog post on marco arena's blog and this is reversing words of a string with ranges and uh you want to tell us a little more about this one jason oh i mostly just caught my eye because um the hashtag that's a rotate and it's interesting because it's transcended it's not just that's a rotate it's now i had an epiphany while programming that's a rotate that's shorthand for having an epiphany yeah yeah that's that's a rotate but um i have to actually honestly admit that the actual implementation here is slightly lost on me, but reversing words in a string using ranges required what a little

bit of extra, uh, algorithm added here. But, um, it's also just some educational bits about ranges that like there's intentional design decisions about what kinds of iterators or your resultant from different filters and stuff. Yeah, I think one thing he said early on is this could be a lot easier if it wasn't because of some of those intentional design decisions. Like you could get almost in one line of code. Split produces a forward range, but reverse requires at least a bidirectional range. Right. So that is why you can't just do split and then reverse the words after the split.

But does a view split, is something in the C++ standard now? Because I didn't try the ranges in the last compiler implementation by C++20. Is that something that you can do in a standard way, or is it only with the ranges V3 from Eric Niebler? I am not nearly familiar enough to keep track of those differences.

Now I'm kind of curious. Because it would be the... What I liked in the article is to see the view split, because it was the first time in my life that I've seen a string split in a one-liner in C++. It did make it into the C++ 20 standard, and it is in the ranges header. So yes, you could do that

in actually one line in real C++ code. Wow, so cool. That's good news, yeah. Because all this srgx iterator, tokenizer, and things like this, this was really like on multiple lines and so on. Having one one-liner for string split, that's really a good thing, I think.

Because I've been waiting that for a while and I've been looking with friends like during, I mean, perhaps weeks or months, we tried to have a one-liner in C++17 without any library and we didn't get one that you could actually recall or months we tried to have a one-liner in C++17 without any library, and we didn't get one that you could actually recall or remember, that was one statement. So that's really cool.

I mean, since whitespace doesn't really matter in C++, anything can be a one-liner, right? Yeah, but I mean, one statement, you know, that you can use and it returns directly. I mean, and then there's maintainability, right? Sure. I love that all of these examples, I'm looking at the CVP references examples for split view.

They actually are like constexpr string views that they're splitting, which I like that. Because, well, you get to reason more about what's happening in the code in that kind of case, in my opinion. But also, the fact that ranges are, I think, fully constexpr capable. So that's also handy. Okay, so Damien and Yannick, could we start off by just telling us a little bit about tippy build and what it, how it got started? Yeah, sure. Thank you for asking. I mean, TippiBuild is the home for native C and C++ developers.

What we wanted to build is a tool that helps C++ developers and C developers to work like if everything was smooth like if your environment was always ready always installed but you don't have to bother of uh um downloading dependencies and that you don't need to uh wait for compile times um and we actually seen by some of our uh first users in our beta uh that uh they spar a lot of time uh with what we are doing uh like sometimes two hours per day. And it's actually, for us, it's a company that we started first as NXXM, and then we renamed it to Tipeee because we incorporated the cloud component to it.

And what you imagine Tipeee is like the extension of your machine in order to build C and C++. So somewhere on the TP is like the extension of your machine in order to build C and C++. So somewhere on the cloud is a running environment that is everything I need it to be. Yeah. It's a bar of it, yes. Okay.

So you can select your tool chain. You say, I would like to build for, I'm a macOS and I would like to build for a Linux machine. And many developers do that. They have like a remote Linux server or they have like a vnc or so or something like this on the server but it's it doesn't feel like natural because you have to drop in a remote window there is lag on the network and so so what you wanted to bring is an environment that you can run and that brings you directly to build your C++ code without any hurdles. So it's a seamless experience, a refreshing experience for C and C++. So you can simply, like say, you are in your editor,

and you code some lines, and the Tp is going to synchronize your files uh to the given environment and it's going to build it there and it's going to bring you back the builds uh so you can like build in parallel for 10 platform like saying i build for linux for windows for mac in parallel and i get all the binaries back that i can then release to others it's also working in an asynchronous way that means you are not um remote on an ssh connection or in a browser window or in a remote window where you are like waiting on the server to reply if your connection is not working if you are commuting and so it's directly something that you edit on your computer you

have the file on your computer but it helps you in adding more ram and more cpus to your computer, but it helps you in adding more RAM and more CPUs to your computer so that you can build in an easier way, in a faster way, actually. And inside TP, to remove all the barriers to C++ adoption, actually, we have a dependency manager that is smart and that is based on a smart algorithm that can automatically build any project based on a code scanning. And naturally, we don't force that.

We are not obliged to use that. But most of the time, people, when they start to use our solution, they switch to the algorithm completely because they just see it works and it's just less work. And it doesn't prevent you to configure stuff where you're not opinionated or saying, like, in this particular case, you want to do something special, you can still add hooks and so on. But the idea is to make C++ as easy as it is to write code in Go

or to write code in Rust or so on. It's like really having a seamless experience. Because one of the biggest problems is having your environment ready, actually. This is what we are doing at tp with tp build yeah and perhaps yannick would like to add a note on the continuous integration uh support that we that uh yes we're currently uh trying to oh frank we are adding support for um github actions uh so kind of wiring up into that to have faster and somewhat cheaper runners.

We are looking to do the same for GitLab and for Bitbucket at this point. So kind of to keep the same level of comfort, so you're still right whatever is native to the source and so to the version management you're using so you still can just keep your uh git uh github um actions uh yaml

and uh so the workflows etc and we kind of try to make it as seamless as possible to just drop in there and bring all the performance and comfort to that. What David actually kind of did mention is you can remove the CMakeList files from your solution mostly and we build them, the algorithm builds them for you. One thing that we noticed is the CI services that you find online, they are priced and sized for web development. When you take a GitHub Action Runner or if you take GitLab CI CD, you pay the minute really in a really costly way because it's fought for web workflow, but are not going to build long.

So the services, they need to have something back for spinning up nodes and building the stuff. So they price the minute in a really costly way. And added to that, the nodes are pretty small, like a standard nodes typically are like 14 gigabytes of space. And if you are a C++ developer and you make a debug build of some big C++ code base, or if you have like a Linux environment that you're building for an IoT device, then it's not enough.

And then the solution is host your own runner and and so on and do a lot of work, while we can just say run zone, double point, label, tp.build.macos and then you get a macOS runner for your build that is priced at a job basis. The idea is that you don't need to pay by the minutes for the CI build, you pay for the parallel jobs. And I think it's really a problem that C and C++ has in terms of build size. I don't know about your experience, Rob and Jason, with build sizes and so on on build times.

Yeah, I mean, I could go look right now, but I just had to delete a bunch of code from one of my VMs so that i could make my next build that i needed to make so there's that although to be fair my binaries had really exploded because i was doing debug builds with ub san and address sanitizer enabled because i was trying to track down something that i could not reproduce on my local machine so it made very large builds in that case um but to that point like uh you said you can just kind of remove your cmake list in many cases because your algorithm's smart enough to pick that up but some of the projects that i'm working on i you know they are building

ruby modules with shared libraries and because of platenform limitations in some cases we have to do like a static link of the libraries for one thing and a dynamic link of the libraries for another thing and then we have to find the system Ruby and link against the system Ruby standard SO that kind of thing like is that still

supported in your environment? I said you are not opinionated on the fact that you can still have in some branches of your project, you can still have a CMake list for example, that will, for one folder decide things. You can also have

declarative configuration, because the problem with CMake is that it's imperative, right? So it's really likely that you generate um cmake lists that are difficult to maintain and that have that needs to be debugged that you need to rebuild often so that you you know what you're doing and um we have like a declarative configuration in the sense we just have a json where you specify where we specify that you auto-fill with what we discover

for libraries that you are using. We fill it with the library we found on GitHub, on GitLab, and so on. And you can then pin versions or say, okay, but I want this special preprocessor argument, or I want this special configuration, this special function for this platform to be selected. However,

if you still need to write actual CMake lists in your code, you can say, okay, I benefit from the TP algorithm for most of my code base, but in the part that is specific to the platform-specific part,

then I will just write a CMake list uh and make a small file as a hidden file that tells to tp that he needs to to read the same the same is there and add it in the in his own process and there you can do some fine tuning and so on but the reason why we went for such an algorithm is if you want to depend on some libraries today, you have to be in the same build system than the library vendor or the library author. And you need it to be properly written. Like writing a proper CMake is for a library, just like a simple header only library, writing a proper CMake so that you can find packages and so on. It's mostly like 120 lines of code.

But most of the time, it's hard to get right. And so for this, we had like different stage of the algorithm. The first thing is if you respect conventions, like the pitchfork layout and so on, conventions, then we just build that based on the conventions. If the convention doesn't work because, for example, you are building for multiple platforms, like you have in your code base, some CPP file for Win32 and some CPP file for Linux,

then we know for which tool chain you are building because you specify that. When you say tp build for Windows Visual Studio 2019, for example, then we are going to check is the headers that are included in this file, are the symbols used in this file something that is part of the platform? And if it is the case,

then we can take it in the build. If we see it's including macOS-specific files and symbols, then we are not going to build it in this process. And the last thing is when you have a configuration error, this is the really hard part. You have a build system that is generating a configuration error or generating files, as you said, for Ruby and so. What is going to happen is we have a cloud,

so we can spin a lot of VMs. You can also do it locally, but you might need a bigger PC. And we are going to try many combinations and find out which one works. And because we also detect unit tests, then we are going to run the unit test and see if the unit test passes and if are going to run the unit test and see if the unit test passes and if there is one where it passes better. And then at the end, we are going to provide the special detection to the user so that he can say, yes, this fits me.

And he has then the stuff built. And we have been working on this since a long, long time. I've tried in 2017 already by putting everything in a single header. And that's why we come then to the other part of the algorithm that bring build speed. And actually, it's the same idea. It's like if you were bringing everything in a single header,

but we split it across files and we make it so that you can compile it. It's just the trick that we use behind. Sponsor of this episode is the PVS Studio team. The team develops the PVS Studio Static Code Analyzer. The tool detects errors in C, C++, C Sharp, and Java code. When you use the analyzer regularly, you can spot and fix many errors right after you write new code. The analyzer does the tedious work of sifting through the boring parts of code,

never gets tired of looking for typos. The analyzer makes code reviews more productive by freeing up your team's resources. Now you have time to focus on what's important, algorithms and high-level errors. Check out the team's recent article, Date Processing Attracts Bugs or 77 Defects in Qt 6, to see what the analyzer can do. The link is in the podcast description. We've also added a link there to a funny blog post, COVID-19 research and uninitialized variable,

though you'll have to decide by yourself whether it's funny or sad. Remember that you can extend the PVS Studio trial period from one week to one month. Just use the CppCast hashtag when you're requesting your license. To back up from the CI, CD, and build configuration stuff you were just talking about, you said you can run this locally, and then you won't have to set up a compiler or anything like that. So it's a fresh environment. I guess you can just get going with tippy what does that look like you know what do you have to set up to connect to your your tippy service um the the first thing is you download the tp binary um like so when they load the drop in your in a command line or you

install a visual studio code extension um we are working on other extensions like Visual Studio as well, but it is not yet done. And then at the first start, we are going to download the default environment for your machine. We have a Clang for Linux. We have a Clang for Windows with libc++ and a Clang for macOS with libc++ as well. Like having always the same uh basic compiler um if you have compiler on your machine we can use them but uh you can also say i want to use for example visa studio and then we are going to because we if we don't find it in your local environment and because we cannot ship it we will then spin a vm where it's it's a it's in there

and the tp is going to synchronize the files of your current folder in a tp build VM where it's in there. And TP is going to synchronize the files of your current folder in TP build node. And it's going to build on this Windows machine remotely and deliver you the binaries back. And actually what our toolchain files are, it's a CMake toolchain file, like specifying all the specific IAs of which options you want, which optimization flags you want, and so on, plus a Packer image. That means it's always

a pair of a toolchain file and a VM. But the VM is only the system, the base system, base compiler, basic tools. You can add the neurons on top so that you have your typical tool that comes with. And then TP is going to build that either automagically by using our algorithm, or if you really don't want, you just say, no, use my CMakeList. But then if you do that and you do it for your full project, then you lose a bit of our advantage is that we can split the compilation we can parallelize it at a finer granularity actually we will spin up nodes based on what you have in your subscription like typical if you take a tp pro subscription then you have like 128

cores included and what happens is when you build we look at the files and we split them. If we see, okay, there is a template association there on an overdue on there, on very, our two functions that are, um, that can be compiled separately. We are going to split them in separate files. Wow. And, uh, if this doesn't make sense because we measured that pre-processing will be higher on each separate file and that you will lose time on the linking part after, we won't split it. But in most of the case, we will be able to split things. And so we will not just build after each translation unit, but we will parallelize after each function that you have in your program

and link them incrementally during the process there. And so that's why algorithm is also a key part, is if you do full CMake, you get the advantage of the environment, the build cache, and having everything remote. But if you do use for some of your folder no CMake, like when you have just the plain algorithm and so on of your application, then we can actually generate the CMake list for you. And we can split the build process in a way, finer granular way.

And because we do that through files, we can drive any compiler. It's not like you need your compiler. It's just a preprocessing step before that makes it possible. And because you have the cloud, we build continuously. So you edit and it builds and you get back the binaries. And in the future,

we might add out reloading and stuff like this. So it's really about bringing seamless experience to C++ developers. So I never, if I understand what you're saying, I don't ever say like type make

on my system. If I'm using TP, it's just building whenever I save a file. Per default. Yeah. If you don't want this, you can naturally disable it and just say TP build yourself on the command line or through a button in the, in the ID. So it's, it's, it's, it's, it's by default we offer that so automatic. We first synchronize and then build and again synchronize every time. But we understand that not everyone wants this so it's also possible to just manually do it. And everything that we offer is command line possible. So it's possible in command line so you don't't need to, you're not tied to some environment and so you can integrate it anywhere. And we are going to open source it,

but at the moment we are actually in a phase where we battle test it with different users. And that's why we, if people join on a website, then they get a seat. And if they fill in the Overtaker questionnaire, we bring them up in the list.

And based on their use case, we get them in our beta. And at the end of the summer, at the beginning of September, October, we will bring an open source release of it and a public release of the solution. Sounds like you're actively looking for beta users to join and try out Tepi right now. If someone has an interesting edge case or something at scale or something they'd really love to try, give it a shot.

It's interesting for everyone, I think. And the point is, we are so, if you take a seat early, because we are a startup, so we cannot open our cloud suddenly to everyone because we will have scalability issues. That's why we need that. And for the moment, we do deployment on a user basis. Like every user gets his own deployment

and we are working on the automatic onboarding so that we can deliver some features to the different users in a more automatic way. And yeah, I mean, in the end, it will be open to everyone, but it's just like we cannot open to all 5 million

C++ developers in the world. They can then build on a platform, or it will just explode on our cloud. Our cloud will just not follow. So we are working on that at the moment. And yeah, scalability issue. Yeah. And what we didn't say is basically

during the time you're not building, you can reuse the resources you basically bought to have access to a remote machine. So basically we have a TPU build and we have a Tippy run part of it. So you can reuse the nodes. Basically you build your application, you're sitting in front of your Mac desktop,

you want to compile the Linux binary and then you can't execute it, right? And so we basically give you the option to use the node to execute the Linux binary in the same environment. And we redirect IO. We're even trying at this point to have some VNC facilities for UI applications to transport the rendering across the network. That's a very, very early pre-alpha. But things going on in that

direction too. Yeah, I'm curious about that in the continuous build model. How do warnings and errors get reported back to me from my code? And I'm particularly curious, since you said you can take one file and split it across multiple compiler instances, how do I get back the warning to know on line 12 that's where my code had a warning? When you do the preprocessing of a C++ file, you know, when you run like gcc with a dash e or dash Dashy, yeah. Dashy is like uppercase E. You get like marker in the file, like that is what was pre-processed, expanded the code,

but the compiler will return a warning or an error at this position or this other position. So we abuse this mechanism so that the compiler, when you get a warning and error on this splitted file, that you get the warning at the right place. It's a bit like source maps. The point is as well, I mean, we try also to keep lines and things like this. When we do modification in the file, we try to add them on a single line,

not to inject lines and stuff so that you get an error at the right place. Yeah, this is an important thing. And we have like during the live compilation, we have like FTX UI from, it's a library that was featured recently. It's one of our users, actually, as we were named in XXM. And we are using the FTX UI library to actually provide you the different platforms.

At the same time, you have the log of, for example, if you build for the three platforms, Mac OS, Linux, and Windows in parallel, then you get them in different tabs of your console. Or naturally, you can still output it to separate terminals or to files, but you can get them live and see, oh, it's compiling on Windows, it's green. Oh, it doesn't build on Mac. Oh, it builds on Linux. So you can then focus on what you want to fix and every change you see directly if you're breaking this platform or this other platform without waiting for the Kotus integration to run.

This is a, because this is the use case we had like, I mean I've been working in a cross-platform development in like IoT and so for ten years before and I always had this problem. I was building for one platform and then I break the 10 overs. I wanted to have this feedback directly and this is one of the solutions we brought there. Actually, for Tipeee,

for the application itself, it's super useful. So we heavily dogfood the thing. So we make heavy use of that feature. And before you spoke about Asan and Ubisan and so on. Yeah. And what I always had as a problem when I was working in teams and so coming to new teams, I noticed that all this stuff weren't set up because you need to add them in your CMake list,

you need to make some setup, you need to have them, and so on. And this is also something that we have in TP, is that we enable all this stuff per default, and we get them run in a nightly, so you get information, hey, what you did today, we found this and this error, and

this is just for us another cloud instance to run in parallel, so that it doesn't disturb your actual build. And it's actually what we would love is that people feel like C++ is as easy to write as writing JavaScript, you know? Like, you just drop some lines and it works. So on that note, then, you said you enable ASAN, UBSAN, whatever in the nightly builds.

Does your build environment also support things like CEP check and clang tidy? And how do I adjust the warning levels if I'm using your automagic feature? As I said, you can still reintegrate well with CMake. In the sense, CMake is your internal tool. It's just that CMake is something that is not meant to be given in the end of the developers. In my opinion, it's like it's like make you know, it's something you don't want to write yourself, you want to be able to tweak things,

but you don't want to be the one that writes that. And what we what we offer is like an opts file. On this opts file, you can add some CMake-specific ID inside it. Okay. But we try to restrict it to declarative things. And regarding the clunked ID on Ubisoft and Ascensio, this can be directly provided in our configuration in json because these are like generic settings that are declarative is not something that you need

to do if else in cmake or something like that that's the point yeah okay well i mean you've mentioned a bunch of different platforms but if you could just kind of lay it out for us what platforms directly do you support at the moment we officially support windows with a clan with a special with a special clang with libc plus plus so c++ 17 and so on 20 is coming um on the linux and and Mac with this compiler. And then we have Visual Studio for Windows x86 and so. And we have like a GCC for some cross-compilation for Linux IoT devices and so. But we have a gigantic list with iOS, Android, and so we have customers that are using iOS and Android in their build.

And they can do it in the sense they can write their own image, like saying, okay, this is my declaration of what the VM should look like in this Packer format. And then they add the toolchain file to it. And as we grow, we are going to have even more of them on having as a test nodes that actually works for this.

We are looking for possibilities to run tests, not only in a iPhone simulator, for example, but running it in a real iPhone and things like this. You are like looking at things like this at the moment with some users. And that's actually the thing that is key behind TP is this pair of toolchain files and toolchain names on the VM image behind.

And you can actually, you don't need a cloud to run it. You can actually deploy it locally in your machine. It's like building on a Docker, for example. But we choose the XTERRA and other level of indirection, actually deploy it locally in your machine it's like building on a docker for example but uh we choose the extra another um level of indirection like in the fundamental theorem of software engineering because then uh you can you can do vms from any kind mac os as well um and you can also do dockers we just don't default by docker on our cloud we don't build in a docker in docker container directly

we will respawn a VM for security reason because we don't want someone to be able to steal the code of someone else or access because isolation is just not good enough yeah yeah so for our listeners who want to just go try this out do you have like a free tier or a trial tier or something like that they can test with actually at the moment it's it's still a closed beta so they have to join uh they

get on the waiting list um but we empty it uh empty it we bring the people up every month in the waiting list and people get it the point is the version that you have is a free version you can use it locally and then you can add stuff that gets with the

cloud and we are going to give like for free some build minutes and so so that you can try um and this free version is really going to be open source um at the v1 release uh we we just uh didn't do it yet because it's a lot of work to open source uh everything um it's a lot to to have like source everything. It's a lot to have like to check it to check out that everything is clean that we brought the repositories in the right folder on that you can react to issues and pull requests this is something because we are still hiring at the moment and so that's the reason why it's not yet open source but it will be

and that's why the beta users get access to it earlier than the others. That's definitely one thing. Do you have any idea when you're going to hit that v1 release date or when you are going to plan to open source it? It's happening this year.

Okay. There's only half of it left, so that's what we go by at this point. Go ahead, Damien. Sorry, I didn't know if you... I saw Yannick Frozen, that's why I'm... But if you hear his message, it's okay. We are releasing this year at the latest in Q4

and otherwise this summer. Now, the parts that you say that you're planning to open source, does that include this fancy build algorithm that you were talking about that can split up our files and make them even that much more parallel? Yeah, because I think there is a lot that the community can bring there. And for example, what our algorithm does is that it follows the information that you get

when you build the file normally. You get information, preprocessing took so much time, instantiating the template took so much time and so on and we use this in our calculation to define what we split what we don't split and so on the I think open sourcing this is definitely something that makes sense because it's gonna being improved and it's just something better for the C++ community in general so it's just that it's a lot of work based on the LLVM Clang parser and so on. And we couldn't open it that easily yet. Right. Gotcha. Cool. Very cool.

Well, you mentioned you're looking for beta users. Is there anything else you want to tell us about before we let you go today? If anyone wants to try just the CI or they have a special platform, a special hosting. For example, we had someone approach us with Bitbucket that we didn't

have yet. So we are working on this now. If the people have like special needs just just just join uh or drop us a mail call us or um write a writer in the overtaker questionnaire just what's really needed uh we will just bring them then a trial version that they can try and yeah enjoy it then okay very cool and what's the website where everyone should go sorry what's the website where listeners should go to check everything out tp.build okay yes which you have underneath your name right now

underneath mine it is written yes so if you're the video, it's been here the entire time. Yes. Okay. Well, Yannick and Damien, thanks so much for coming on the show today. Thanks, Rob. Thank you very much, Rob. Thank you very much, Jason.

Thank you. It's really nice to be there, to speak here. I really like how you maintain this flow of podcasts every week. That's really awesome. You're a really great team. Let's see if we can help you further in the future.

Okay, great. Thanks so much for listening in as we chat about C++. We'd love to hear what you think of the podcast. Please let us know if we're discussing the stuff you're interested in or if you have a suggestion for a topic. We'd love to hear about that too. You can email all your thoughts to feedback at cppcast.com.

We'd also appreciate if you can like CppCast on Facebook and follow CppCast on Twitter. You can also follow me at Rob W. Irving and Jason at Lefticus on Twitter. We'd also like to thank all our Patrons who help support the show through Patreon. If you'd like to support us on Patreon, you can do so at patreon.com slash cppcast.

And of course, you can find all that info and the show notes on the podcast website at cppcast.com. Theme music for this episode was provided by podcastthemes.com.