Revit Journal Files: They Aren’t Just for Autodesk Support

BRIAN MACKEY: Good afternoon. Everybody having a good AU? Midway through-- it's pretty good. All right, so Revit journal files-- hopefully everybody's in the right session. Of course, I think the scanning people would've yelled at you if you were in the wrong session, so I think we're pretty good there.

So just a couple things about the session as we get going-- I do like to make sessions interactive. So if you have questions while we're going through it, feel free to raise your hand and ask it, partially because I want everybody to get their questions answered, and the other reason is I won't remember what I said 10 minutes ago. So I don't think everybody here knew that I had to con Zach into doing this. He got conned into this last year at RTC Europe, so I conned him into it this year at AU as well.

ZACHARY KRON: It's the long con--

BRIAN MACKEY: The long con.

ZACHARY KRON: --is unrolling over years.

BRIAN MACKEY: Yeah. So I also learned the very first time I taught this session at RTC-- what people thought it was going to be is what it was not. So I put this PowerPoint slide up here. So here's your chance to leave and go to a better session if you want to. But we're not going to be talking about troubleshooting journal files, and we're not going to be talking about understanding all the stuff that is in a journal file.

What we are going to be talking about is how the developers actually intended the journal files to be used and how we're going to do an unsupported feature from those journal files and using them for scripting. [INAUDIBLE], yes, I've been told by Autodesk I should say that several times, so you're going to hear me say this quite often. So that's what we're actually going to get into. And so who here is using Revit journal files for anything? Yeah, quite a few people. Anybody want to give examples what you're using them for?

AUDIENCE: Automatic printing.

BRIAN MACKEY: Automatic printing. Troubleshooting, I heard.

AUDIENCE: Batch purge.

BRIAN MACKEY: What?

AUDIENCE: Batch purge.

BRIAN MACKEY: Batch purge-- actually, I'm going to show that one. All right, so from the help file, journal files capture all of the actions taken by the software and dump it into a very beautiful little text file. Theoretically, if you actually read a little bit more in-depth into the journal files, it does talk about how you will submit these to Autodesk support. Who's had Autodesk support ask for journal files? Who automatically just sends them anyway because you know you're going to get asked anyways for the journal files, right?

So that's what they're used for on the other side of things. But in reality, they were used for software development and testing. And I could speak about this, but this is why I brought Zach up, because he used to be part of this process, and he can speak so much more intelligently on it than I actually can. So this is why I brought Zach in.

ZACHARY KRON: Sure. So hi, everybody. My name's Zach. I work at Autodesk. I've been at the company for-- this is my 11th AU, coming up on 12 years. I came out of architecture practice and went straight into working on the Revit team without actually having used any Autodesk products, actually, at that time. And the first thing that I did-- my introduction to Revit-- was working with journal files. And basically, rather than drawing stuff directly through Revit and doing all the rest of this stuff, how do you interact with these weird things that come out of it?

So I came in with the quality assurance team, which is basically the people who make tests and run tests and make sure that Revit keeps running the way it's supposed to. So my first task when I joined Autodesk was-- we had changed the algorithm for how roofs were made. And so we had this whole stream of tests that verified, when somebody drew a roof, that it made the roof in the proper way. And so we had all these tests that verified [? that ?] [? that ?] were now invalid because we were making them in a slightly different way. So it was basically going through and recreating this method of automatically testing the process that Revit was making roofs.

So as this slide's showing, the reason that we do these sorts of tests is that Revit is a very big software project. And every time you make a change to it, you need to manage all the things that you did before, so all of the things that you did that everybody else relies on. Whenever you make a small change, you need to make sure that your change didn't just improve the thing that you did, but it improves and doesn't break all of the things that came before it. So we have lots of people that are submitting code into making Revit. We've got lots of people concurrently making submissions into it.

And so in order to organize all of those submissions, you need to make sure that there's a constant way of verifying that the application continues to work the way it's supposed to. We don't really have a central management force around that. It's almost an entirely an automated process of making sure that the application continues to work when people continue to make submissions to it. There's lots of people making changes, so that there's dozens of changes being made at, really, any given time. All of the teams need to be coordinated about how they're working together on these things.

And there's an idea that everybody who's developing on Revit is in it together. If one person breaks something, it affects lots of other people who are working on it. So the idea with testing and the idea of these large software projects-- it's, in a lot of ways, very much like what's going on with architectural projects in that there's intent. When you are making an architectural project, you're trying to capture the intent of what's going on in the building. When people are making art software projects, they're also trying to-- while they're making very small changes, they're trying to make all those small changes that align with the larger spirit of what the application is doing.

And when we have this testbed, it's a way of ensuring that that intent is maintained-- thank you-- which brings us to, specifically, what journals do. Journals are part of regression testing. Has anybody here heard of regression testing in the past? A couple people, OK. So regression is when something used to work one way, and it doesn't work that way anymore. It has regressed. It is not working as well as it used to. Regression testing is something that I always think should be fundamental to the way that people see how software is made, but it is surprisingly absent from many applications.

Revit was built from the beginning knowing that it was going to become very complicated, and it was going to need to make sure that when you changed windows, that it didn't break how stairs worked. Because unlike many other applications, everything is very tightly intermixed. We've seen breakages where somebody changes keynotes, and it breaks treads or something else. It's almost like one big hydraulic system where you push down over here, and then this part goes up over here.

So the regression tests, these journals, are a way of saying, I'm going to have a test that makes sure that stairs continue to work the way that they do. And then when I make a change to schedules, I'm actually going to run the test on stairs to make sure that my schedule change didn't break my stairs. And I think that this number actually should be updated. I think that we're over 20,000 automated tests right now. And I think that we get into how we make these in a second. I'm going to skip over that.

So like Brian was saying, the way that we use these tests is-- there's multiple variable ways. Testing is the primary way. Diagnostics is another way of using it. And you guys have all submitted in these journals for your own problem reports. The way that we actually make the tests are-- again, it's a little bit different with Revit than many other software programs where you have the developers who are actually making many of the tests for it.

What we've done with Revit is we've made it so that subject matter experts or domain experts can actually be making these tests. So I came in as an architect and started sitting down with Revit and making tests. And part of the reason for that is that we wanted to make sure that, when we were testing the application, that it was being tested as though a human was using the application. So I would come in, and I would make some walls, and then I would run the wall test. And what that's allowed us to do is basically scale up this giant, giant testbed.

So we have a few people that come in. They act like architects. And I would always tell people when they're asking, so what do you do at Autodesk, I go in and I act like an architect. And maybe that means that I drink a lot of coffee, and then I don't give myself enough time to get something done, and then I make it really, really fast. So the tests, essentially, are the reproduction of that. So I will go in and I will drop a bunch of walls, and I'll put a bunch of windows in it. And then you scoop out the journal tests, and you put it into this giant farm, and that thing will run in perpetuity.

So the kinds of tests that you'll see running in this testbed are everything from very, very simple, open up Revit, make a wall, place a window into it, to things that are these elaborate things that take hours to run and create entire buildings. And they're quite beautiful to watch, because it's like watching somebody sit down and draw an entire building really really, really fast, because there's no pauses in between. It's--

[FAST TICKING SOUND]

So that's how these tests get created. We were, for years, running it on our own farm before data centers existed in an accessible way. We had a big room that was just packed full of PCs. And if it had 12 cores on it, it would fire up 12 instances of Revit, and they would all start playing these journal files. And it was bizarre to watch, because you would just see--

[FAST TICKING SOUND]

--all these Revit situations opening up and executing. That means that, for all of these journal files, we've built this harness. It's called CrsTest. Anybody know what Crs might mean in relationship to Revit? No Revit historians here? So before--

BRIAN MACKEY: Charles River Software.

ZACHARY KRON: Charles River Software, OK, good. So before Revit was acquired by Autodesk, it was started by a group called Charles River Software. And you see little bits and pieces of the history that persists through the software through over time. So CrsTest was a harness. And it's basically an automated process that says, give me a pile of journal files, and give me an instance of Revit, and I will start taking the journal file, dumping it on this executable and running the test and shutting it down, and then getting another one and so on and so on and so on.

There have been other people who have, since that time, made other versions of it, but that's the entirety of the system, really. There's a giant testbed of these text files, there's CrsTest, and there's the ability to start cranking these things through it. So any time somebody makes a code change, CrsTest fires up somewhere and starts churning through all of these tests.

BRIAN MACKEY: Am I the only one wondering if they're in license compliancy with running 12 versions of Revit on the same machine? OK, sorry, that's just where my brain went.

ZACHARY KRON: We own that.

[LAUGHTER]

So since then, we've of course virtualized a lot of this process so that we can run these things on data centers. When you're running each one of these individual things, the degree to which you can paralyze the process is entirely dependent on how many machines you have to throw at the process. It used to be that we would maintain all of the machines that would actually do this. Since then, we've started scaling it up because the application's gotten bigger and the number of tests has gotten bigger. Oh, and then this is--

BRIAN MACKEY: That's back to me. I'm going to get into, I think, some of your [? layer. ?]

ZACHARY KRON: OK, well one other thing I would just say about this--

BRIAN MACKEY: Go for it.

ZACHARY KRON: --whole process is that, while the whole journal ecosystem is really built around this idea of-- journals are supposed to break. That's one of the funny things about them. Brian's going to show a bunch of useful applications that he's figured out that you can do with journals, but the essence of journals is that the moment anything goes wrong a little bit, it should just not work, because that's the essence of what they were built for, is to be very, very sensitive little spiders going around and doing very specific operations. And if that operation isn't exactly in compliance with it, it should just die. And you'll probably [INAUDIBLE].

BRIAN MACKEY: I got that later, yeah. So just talking about that-- so journal files, great, but has anybody used some of these? I know a few people [? have ?] [? said ?] [? so. ?] Is anybody old to Revit, back when you used to actually get disks before the USB drives? They actually used to ship a file called the Family Upgrade Utility. Has anybody ever used that here? Yeah, so a few of you guys have seen that. They stopped shipping that when they determined this was an unsupported tool.

So back in the day, they actually used to put this on there. There's actually suggestions in the Autodesk forums. [? There's Words ?] you can still go download it. I know I've posted an updated version on that in the Autodesk forums, too. And as Zach had been talking about, [? the ?] [? ones ?] [INAUDIBLE]. Has anybody ever ran the RFO Benchmark? All right, so you guys have actually seen the building open in [? Spain ?] and create hundreds of views and thousands of groups. And so those are two commonly in the industry right now people are using for journal files out there, right?

And it's actually, as Zach said, beautiful just to watch this building getting spun, and you're like, oh. It's like the old defrag. Anybody use the old Windows defrag? You saw little squares moving, and you would just sit there and watch it, going, I can't look away. It's kind of the same thing. So the thing about journal files-- where I like to do it is-- when I saw that original upgrade utility, I'm like, so I'm just dragging and dropping this journal file onto the Revit exe. What else can I do?

So that's what's really cool about it, is you can take journal files, create a little executable for it-- not even executable, it's just a little BAT file-- and then you just drag and drop that on top of your Revit icon, and all of a sudden it starts to go. So this is definitely something I use all of the time to upgrade my families. I know there's a whole bunch of add-on utilities. People have ones you can charge on for upgrading all your families. You can actually do this very simply with a BAT file. So that's one of the ones I like to go through. The thing about it is-- yeah, so it's got to be exactly the same. So they are made to break. So it's a very fragile environment, too. And we'll start to show this as we start going through and getting into this.

So for those of you who have not been told by Autodesk support every time you submit a receipt, this is where the journal files are located, so near Local App Data, Revit, whatever version of Revit, and then under your Journals folder. And like I said, if you actually open this up, you can actually be mind boggled, and you start looking at all the stuff inside of there. What I actually find is very interesting-- the development of Revit over time has been happening-- when you actually go to the [? beginning ?] of a journal file, it tells you all the add-on utilities that are being installed.

And way back in the day, when I first got into this, it was only anything you installed, but you actually start to see more of the programming languages getting broken down. So more and more of the tools that you have inside of Revit are technically, by the journal file, considered an add-on utility. So it's actually cool, as you can see the development of how they're breaking the different things out every year. So it's nice for me to go in there, start looking at, and see.

So like I said, when you get in there, there is a whole ton of data. It's got every single mouse move. It's got dates and times and when you did it. It's got stuff I don't understand. But the big thing you'll start seeing is you'll start seeing like GRN mouse move, ribbon event. Those are the things that are actually utilities of things you have currently done. So that's exactly what's going on. It gives you dates. It gives you times and up the beginning, et cetera. It gives you all of the data about your machine, your add-ins, your printers installed, et cetera, et cetera.

The one thing I will say-- and I don't remember what year it was. They actually came in and put these two lines of asterisks before something actually really is happening in Revit. There's, like, 16 pages of data at the beginning. So if you're actually trying to go into a journal file and see something that you just did, just do a search for eight or nine asterisk in the txt file, and that'll take you down to stuff you can actually possibly understand besides your printers installed, the network you're installed onto, your browser history-- no, I'm joking-- those types of things.

So for me, what I end up doing is I end up creating a little template, or a little basic template file I call for this. And the beginning part of my template file has all the stuff it needs to open files, also what file it's pointing to for the files it's going to open. That little area you see highlighted in my template file-- it just says, hey, insert your copy-pasted data in here. And that's what I love about this. Who here is not programmers? You all can do this, because it's literally open up Revit, close Revit, copy it, open up the journal file, copy it from here, paste it here and save it, drag and drop an icon. It's really that simple.

So this is my introduction into, you don't have to know Dynamo to do a whole bunch of tedious tasks. So that's really what ends up happening on the journal files. But when you're actually using a journal file, at the very beginning of that journal thing, you actually need a file to tell it what families you're going to be opening or what project you're going to open. The thing I will say is I use this mostly for families, for purging families, adding families, upgrading families.

You can use it on projects. It's really unstable on project environment, trying to get it to do a lot of things. Because like I said, every single thing has to be identical in the project or in the family. So it's weird when you get up doing a side of that. So I have a little file, and that's the extensive lines of code that basically says, take every RFA in this folder and copy it and create a txt file. So take the folder path. Take the family names. Dump it into a txt file.

So in the upper hand corner, you'll see that's what I have in there. I also have it go through and delete backup files and journal logs and all these other things first, just so I'm not upgrading backup files. Because the first year I did this, I didn't. So I upgraded a whole lot of backup files. That was fun. So then I had backup files and backup files. So it was really fun. And then what that file does-- it just generates this little thing down here. You'll see it gives me the whole path. Hey, it's under this folder, this is the family name, et cetera.

So you do have to have a txt file that does contain all of the files, or families, in my case, that you're going to want to be up upgrading from. And then when you want to run the journal file, you simply take that journal file. You drag and drop it onto the Revit icon. For me, I've always found this Revit icon has to be on your desktop. You can't drag it to the Start menu and get it to work. So you have to have a copy of the Revit icon on your desktop. So that's how it's gone set up. And this has not changed since I've been doing this in Revit 8.0, I think it was when I started doing all of this.

Like I was saying-- this is where Zach jumps back-- it's an extremely fragile environment, right? If one thing is wrong, it just blows up, and so I've got to enter interactive mode. That's a tongue twister, right? So it's also funny. Has anybody ever wanted to run Revit with none of your add-on utilities installed? Create a journal file you know will break, and you're now running Revit with nothing, no external add-ins going.

I laugh because there was a whole thing, and I know Robert [INAUDIBLE] actually posted something up there, how you can run Revit and have a little script run Revit with no add-ins installed. Yeah, this is how I do it. I literally have a journal file I know will break. I drag it on there. Revit opens. I've got to go interactive. Great. Now I have no add-ins installed. So that's my little unsupported, no add-ins installed version inside of there as well. So why are things bad? Well, this is where Zach jumps in, and the whole reason why we had journal files.

ZACHARY KRON: Sure, so these are the kinds of things that we use the journals to detect. So along with some the more basic things, like if you have, in the past, used a journal-- if you recorded your actions and you did an array, you did an unassociated array and you made 64 elements, you can make those 64 elements and then select all of the things, and the journal keeps track of how many things were selected.

So if somebody makes a change, and then you do your array and only makes 60 elements, and then you do the selection, the selection will say, you selected 60 elements. And then the journal will break because there will be a bad match between what happened before and what's happening now. So that's the most basic elements of it. Within those things, what the other things that we do with it are-- so that's basically a selection comparison, that element in the middle.

There's more sophisticated things that we've done where we've added onto the journals to do things like image comparison-- so there's a lot of stuff around rendering-- and different image styles where there's pixel-for-pixel comparisons to make sure-- they're incredibly conservative. They want to say any change is not a good change unless proven otherwise, so those image comparisons where you have something like, maybe the blue on the right is a nicer shade of blue. Well, it's not the right shade of blue, so it's going to fail. Just numerical comparisons, just making sure that things like schedules keep adding up to the same thing. I think this is you.

BRIAN MACKEY: Oh, yeah, this goes back to me. So just some journal file examples-- I'm going to walk through this here in a minute of how can we do this journal file example. So these are [? sums ?] that I use quite often. Who gets very frustrated when you go to insert or browse a Revit family on the server, and somebody didn't turn off the reference plane, so all you see is a big green cross on the screen? Is that not the most irritating thing?

This is one of the first journal files [? I ?] run any client I go to. They have me come into their office. I do this as they're talking. I'm running a journal file in the background to turn off all the reference planes in all the families because it irritates the crap out of me, right? So that is one that I do, is just turn off all of reference planes [? in ?] families. Another one have been-- I like to rename view types. Again, most of this is what I do inside of families.

Purging-- I know somebody said they use this to open up all their families and purge all the families. So these are just a few of the examples that I use. I very like things in a specific way. So I've got one that goes in and renames all the leader arrowheads to be dimensional, so I don't have dimensional [? three ?] [? 30 seconds, ?] or whatever. I want a linear dimension style. I want an angular dimension style. I don't need names. I don't need descriptions.

So I go through and rename all the dimension styles, all the arrowheads, everything like that so I have a consistent thing in all of my families. Because I hate going in, and some of them have different dimension styles. Some have arrowheads. Some have ticks. I like to be consistent in everything I do, so just little things like that that you can start going to.

And again, remember this is intended for internal testing. It's not officially supported. And I will let you know that I have some families that have bugged out on me that I've sent to Autodesk for support, like, well, how did this happen? Well, [? I read in the ?] journal [? file, ?] [? like, ?] yep, nope, done. We're not helping you. Literally, I got that response, like, oh, we can't help you on that one. So I have had some families have issues. I don't think it was because of the journal file, but since I used that term. So if you're doing something like that, just don't tell support that's what caused it.

[LAUGHTER]

We're being recorded, so I'm hosed there. But yeah, so just to let you know that this is unsupported, so if anything breaks, you've got to hopefully find people in the environment here to start going through and looking at. So let's just start jumping into this and really seeing what's going on here. So that's right. I do not have Revit open. So I'm going to go ahead and open up Revit here. And just to show you guys what's going on as it opens, when I go to the Journal folder-- yes, question.

AUDIENCE: Why is it not supported?

ZACHARY KRON: So--

[LAUGHTER]

So every year, basically, there's some changes that happen between what journals do and how they behave because it was designed and used as a testing tool. And there are lots of things that we intend to just not support in it as we go forward. So if we change how a journal test is being executed, it's an internal development tool. And there's an additional overhead for anything that's a supported tool, for everything from notification of people who have deprecated functionality to documentation to training people in how to use them on the support network.

So it's basically, in a world of limited resources, what are the things that we are going to say are features? So journals, as used as intended, are supposed to be fragile, breaky things that don't work very well. So that's the main reason, is that they aren't supposed to be something that is a feature. It turns out that there's useful things that people can do with them.

And actually, one thing that we can talk about is that-- one thing that they are supported for is that people use them to make regression tests for API tests. And people who are making third-party applications have started using journals to do their own regression testing. There's communities to talk about that sort of thing. And actually, we'll talk about that a little bit later on, is that now there is an open-source, essentially, CrsTest tool to allow people to test their own add-in applications. Anybody here an API developer? Yeah? Do you have any way of automating your testing process?

AUDIENCE: No.

BRIAN MACKEY: You do now.

ZACHARY KRON: Now you do.

AUDIENCE: [INAUDIBLE].

ZACHARY KRON: What's that?

AUDIENCE: [INAUDIBLE].

ZACHARY KRON: OK, yeah, excellent. We may not have a slide about it, but basically, there's a tool called Revit Test Framework made by the same people that brought you Dynamo, which is essentially-- it's very similar to the CrsTest, and it is for people who are doing reasonably complicated application development on Revit if they want to ensure that it continues to work as they work with it. And it's just the same thing of saying, you make your testbed, and then every time you make a change, you run Revit Test Framework, and it'll load all those journals, and we'll give you a report about what failed and what didn't fail.

AUDIENCE: So if we're trying to [? duplicate ?] the functionality of journal files [INAUDIBLE], is the [INAUDIBLE] [? fill ?] an application [INAUDIBLE] on startup, like an add-in?

ZACHARY KRON: Sorry, can you say that again?

AUDIENCE: So with the journal file, [? the way ?] we use journal files is to automate a process on startup, right? But you can create an application or an add-in which does the same thing. Is that the [INAUDIBLE]?

ZACHARY KRON: Well, there's a couple things. You can create a journal file that fires off specific API applications. And if that specific API application continues to function as it did when the journal was made, you now have a test for your API application. Now, you're asking if you've got an API application which fires off a journal?

AUDIENCE: No, I think what I'm asking is, what's the officially Autodesk supported way of automating a process [? on Revit ?] startup?

BRIAN MACKEY: [INAUDIBLE] what's the official Autodesk way--

ZACHARY KRON: What is the official process for automating a process on startup?

AUDIENCE: Yeah, so for example, [? these journal ?] files are automated [? printing. ?] So when Revit opens up, and [? a ?] project prints, it selects the print range, [? the paste ?] [? setup, ?] and then closes, right?

ZACHARY KRON: Right.

AUDIENCE: But I think you can also do that by creating [? an add-in ?] which will run when Revit starts.

ZACHARY KRON: Oh, well, I mean, there's macros, which will detect on startup and can execute on startup, that sort of thing. I mean, the official way to do functionality, printing anything that Revit's supposed to do-- there's sort of a meta conversation here, right? There's the things that you're trying to do that you would do through the interface of Revit. The official way to do that is you make an API application that either runs as a macro that's part of the document or that runs as part of the application session, and it detects a startup event, and then it fires off what that's supposed to do. Journals are just to make sure that you're add-in keeps doing what it's supposed to do.

AUDIENCE: [INAUDIBLE].

ZACHARY KRON: Yes. Sorry.

BRIAN MACKEY: And correct me if I'm wrong. Can't you also use Dynamo [? to, ?] when you're creating an add-in, say, also add this to the Revit journal file?

ZACHARY KRON: Oh, Can you use Dynamo to [? add-- ?]

BRIAN MACKEY: Or not necessarily Dynamo, but when you're creating your own add-in, you have to tell it to add to the journal file. Because then, a lot of times, I'm going through journals that just said, hey, this add-in did something, and then it goes to the thing I did after that.

ZACHARY KRON: Oh, yeah, yeah, yeah, you can add journaling functionality to your add-in so that it actually does a more verbose recording of what's happening. Out of the box-- this is getting obscure in an already obscure class. Out of the box-- if you've got an add-in, it will journal that you launched the add-in and that the add-in executed. It won't say anything about the nature of that execution. But there's a lot of documentation about how you can add that functionality to your add-in to be more verbose in what gets recorded in the journaling process.

BRIAN MACKEY: Yeah, so for those of you guys in here who did say you guys do a lot of add-in stuff, I do like to note that, because I know I have quite a few add-ins in my Revit, and some of them do that, and some of them don't. So it's just always a little bit frustrating when you're going in this like, oh, great, this external command ran, and then I went into erase. Well, that external command had nothing to do with that. So just nice-- if you guys are doing that stuff, add that external journaling in there so maybe, possibly, end users can extract some of that, or B, if Autodesk support sees it, they might know a little bit more of why something broke. And they can say, hey, it's definitely that add-in.

ZACHARY KRON: And Jeremy Tammik's got a bunch of documentation about how to add that sort of information, too.

BRIAN MACKEY: So I opened up where the journal files are located. The other thing that I don't know if a lot of people know-- did everybody know that the Journal folder also creates a nice version of the file or family you had open? So if your backups are ever really tanked, you might want to go to the Journals folder to try to save your life. I've actually done this for a couple clients.

I've also had some very weird issues in Revit where I'll fix a corruption in a project and it'll keep coming back until I delete the files out of the journal. And then, once all those files are out of the journal file, it stops coming back. So just so you guys know, if you are having issues, and you've went in and detached, created a new central, and you deleted all the backups and all the locals, go delete everybody's journal folder as well, because I have seen some of those issues go back into Revit. I don't think they're supposed to. But once I clean it up here, it's there.

So you'll see, if I come in here and I just start looking at these-- and I've just got them all sorted by name-- I've got all of this stuff happening inside of there. I'm just going to go switch this to date modified. And you can actually see that, OK, every time I've run Revit-- you can see I've ran it today quite a few times. So here's all the different times today that I ran Revit. So every time you open up Revit, you close Revit, you're getting a journal file. When you open up that journal file, it's going to go through and record every single thing you've done, all right?

So I'm going to do something very simple. I am just going to grab-- sure, we will grab this light fixture. This looks great. I'm going to grab a light fixture, [? or ?] some sort of family I have. Once Revit opens this, I'm just going to go do a couple commands. Now, one thing I will always tell everybody is avoid using two-key shortcuts if you plan on using what you're doing for a journal file. Because you'll have a two-key shortcut of VG for Visibility Graphics, and somebody will decide that's the wall command. And so it'll go try [? modeling ?] a wall command for them, OK?

So for me, I have found over the years of doing this, no two-key shortcuts. So if I wanted to go in Visibility Graphics on this to turn off reference planes, or I'm going to go switch to a floor plan, go to the reference level to turn off reference planes, whatever, as I start going through and doing that, I am always going to be using the mouse click. This is the other reason why you saw one of my sample files had renaming views. This view is called REF Level. If I open up a different family, and that's called Level 1, if that's called Plan View, if that's called something else, the journal file will fail-- extremely finicky, fragile environment. That's what they're made to do.

So for me, it was funny. One of the first things I did was like, oh gee, I had 50% of my families-- it was called Reference Period Level. 50 of my families were called Ref Level. Some of them were just called Plan, or whatever it was. So I literally created five separate journal files to go rename those views. And it would tank out on me, and I'd be like, all right, let me figure out which ones have these views, which ones don't. So this is not something that's that simple. It does start going through to look at it, right?

So then I'm just going to go into the visibility graphics. And again, I'm not using VG. I'm going to say I wanted to go to annotation category, and I wanted to turn off reference planes, and I say OK, all right? I can save the file if I wanted to. I can actually just close out of Revit. The journal file will still pick up on all of that information. I don't actually need to save. I don't actually need to do anything else. I just need to go through and start setting that.

Now, as Revit's closing, I will go back to my little journal folder. I'm going to wait a few seconds, because it does take a little bit for Revit to [? write. ?] And to let you guys know, I actually do use Notepad++ to edit text files. So hopefully everybody here who's ever done anything uses Note-- even if you don't, get Notepad++. Notepad sucks. I'm sorry. It's terrible. So at the very least, go download the free copy of Notepad++ just so you can start editing things with Notepad++. It just actually makes things and groups things a little bit better than Notepad.

So like I said, when I open this up, you'll start to see it's coming through here. It says, hey, gee, I opened up Revit. This is my version of Revit. This is the time I did it. It started making this journal file. I always want to know, is that millisecond accurate to when it started up here or when I got to line 3? I'm weird. OK, so we start coming down here, talking about all this stuff. But like I said, for me, you could actually go search for a whole bunch of asterisks in a row, and it's going to actually take you down pretty much to where you started going in and actually doing something.

So it'll come down here and say, OK, that's just File Checker. Here we go. I went into Floor Plans, and this is everything I did inside of that file, right? You could actually go through and see what you did for a day. If your boss says you did absolutely no work, you can send them a journal file that's 400 pages long and say, BS. Look, I was working. Of course, if you just had the Homer Simpson little bird drinking water, clicking a button, it would still register [? that, ?] [? right? ?]

But you can start to come through here and see this is everything you've done. So if you really wanted to say, hey, that's literally all I wanted to do, you could just come down here and copy all of this stuff to the clipboard and paste it in, and you are done once you have that template file. Personally, for me, I don't like seeing all of the pointless stuff. And the pointless stuff is everything that starts with an apostrophe. If it starts with a little apostrophe, that's just information for you to look at. You don't really need to start getting all of that.

It's like all of these 000's That, I don't need. I definitely don't need anything that's got the apostrophe, letters, characters, et cetera. I don't need any of that. So for me, I don't like to have all that excessive data. I go delete it all out of there. Now, I also do have a little file of-- and actually, in '19, they did change quite a bit. So in 2019, they actually did start adding-- all the 00's and stuff, if you go to journal file in '18 or '17, you didn't get those. That's a new feature to '19, which again is why it's not supported, because they just start randomly changing things, like, oh, OK.

AUDIENCE: [INAUDIBLE]?

BRIAN MACKEY: Yes, so you also can come in here. And what Zach just did as I was talking is you go to View tab, and you can say Visualize in Visual Basic, and then it'll start telling you, this is stuff you actually need. This is stuff you don't really need, right? So the red stuff, you don't really need. I also actually have a little thing that one of the Autodesk programmers gave me. It's a little executable file that will just go to these journal files and delete all the unnecessary stuff. And so you're just left with lines of code and stuff you actually need.

AUDIENCE: [? Somebody gave ?] [? you the ?] Perl script?

BRIAN MACKEY: Huh?

AUDIENCE: [? Somebody gave ?] [? you the ?] Perl script?

BRIAN MACKEY: Yes, so I do have the nice little Perl script that goes through there. So if I go into here in my data sets, I do have this remove comments and blank lines for all the journal files. So if you guys want that, email me. I'll give it to you, because I can't post data sets. So I had that all up there. And so if you want that, you could double-click it, and that'll get rid of all the excessive lines.

What I don't like about it is it all jumps it into a single line. So you might get one line with 6,000 characters, and you're like, how far do I have to scroll to copy? So it's there. It does remove all of the returns as well. So this is what's inside there, and that's what your journal files are doing. So if I wanted to come through here and be like, OK, I just really, really, really wanted to start copying that stuff, like I said, I just need to come in here and say, OK, we started at the journal browser. We can come down here, grab all of this stuff. You can delete.

Personally, for me, I usually go through like, yeah, I really don't need this. I'm going to delete those lines. It just makes life a little bit easier, in my opinion, to start visualizing it. I don't necessarily delete every single thing inside of there, but I do start to delete a lot of-- I don't really need these [? Es. ?] I don't need that. This is just me being type-A personality. It just makes it a little bit cleaner. Especially if I'm going to be saving this to be used over and over and over again, I really want to have something really clean so I can really understand what I'm doing.

So then, once I've done all that, I can copy that to the clipboard. And like I said, I have created one for myself-- and not that folder. I have created one for myself that I just call it my script template. So in my script template, I can come in here now, take what's-- right here, it says Insert Custom Information Between These Lines. I just do Control-V-- oops, I guess I didn't copy it-- in that area. That's what it's going to take. Now, if we actually look at my little template, what's happening at the beginning is it's coming in here, and it's coming here in saying, OK, we're going to start this journal file script.