bloop-ai

An AI-powered code search engine that enables developers to efficiently navigate and understand codebases using natural language queries.

bloop AI

How we doing AI nerds? We good? All right. I never demo. I always like MC these things and it's like now the food critic becomes the chef. So you know we experience, right? I do have a day job other than running random AI events. 

What I do is I help modernize mainframes and COBOL running on those mainframes into Java, at which point many of you are probably looking for the exit to this place. That is like the most boring thing you probably ever heard of in your life. For those of you who don't know what a mainframe is, which hopefully is most of you, um, these are archaic computers that have been around for 60 years. I think the mainframe celebrated its 60th anniversary this year. It was like, you know, the server before the server. 

It's the most reliable type of computer pre-1990 and it's so sticky that it still runs in most of the Fortune 500, especially amongst banking customers. But they have a big problem because like most of you are thinking, who the would buy a mainframe in 2024 and learn that as a skill? There are many more people retiring with these skills than there are joining the workforce. 

So what's the solution? We convert people's legacy programs into... I've put Java in the middle of the evolution chart. It's more modern than what they were on, but it's definitely not like the most modern thing possible. I have to set this up a bit because all of the demo is basically VS Code, so forgive the slides. But essentially, if they give us a source program, our job is to... 

Convert that into a Target Java program and we do this in two steps. The first is to transpile the code from a legacy language into a modern language statically, so kind of like a compiler. And the second step to that is to refactor it using an AI agent. 

I'm sure everybody knows roughly what AI agents are. Um, you would have heard of Devon, you would have heard of DEA and open Devon and Devon and all of these ones. And there's probably some other ones that should be on this side of the side. But imagine like the architecture of all these things is essentially the same thing. Ours is actually very similarly architected to a lot of those things. 

There is a big difference in use case. Like we believe that Engineers like to build new stuff and actually there's a huge amount of opportunity in automating a lot of the menial maintenance that goes on. Um, in companies as opposed to trying to automate building all the new cool stuff which what the developers want to be doing. 

Okay, uh, so let's look at some Cobalt. Who's excited? See some Cobalt? All right, so what are the cool things we can do with an AI agent when we're trying to refactor Cobalt, which is one of these really old Legacy languages, um, to be much more readable? 

So my first example is a function to format a date. Now when Cobalt was invented 60 years ago, there was no function to format a date. If you wanted to do that as a software developer, you had to write the function to format the date yourself. So what do we see here? We get the current date and then

Basically we're moving slices of the current date into a string in order to format it. Now obviously today what would you do? You'd have like some Java function that says you know ddmm y y something something. But that took you know whatever 40 years to invent. So what I'm going to show you now hopefully is um is how we can automate the process of cleaning that up. Because wouldn't it be nice if I refactor code took advantage of these modern libraries?

So just for reference when we uh when we start the uh with the Java so I need to find the equivalent Java quickly. So this is what the Java equivalent function looks like. Can everybody see that okay? Does it need to be bigger? Zoom in big in big there you go. Um so it's basically line for line in Java exactly the same as what the cobal was.

So what we're going to do now is run a um is run the the process and I'm going to step through what is happening line by line. So H give it a sec to start running. So we give it an instruction. Uh you can see the instruction in the first prompt here and sorry this is really like not beautiful. So I've got this little utility that helps me just step into exactly what is happening.

Okay so the first thing is given this code and the task the program is originally cobal transpiled to Java refactor the code to use Java's native date formatting instead of the current approach. I wrote that myself. In reality there is actually another system that sits above the system that I'm demonstrating today that comes up with the tasks that. 

This agent performs so what is the first change to make. This is super important breaking down this big objective into something that can kind of be achieved in a few lines of code. So uh and the response to it is let's import the necessary Java date and time classes. So that seems that seems pretty reasonable. 

Um so what we can do I'm not going to show the prompt for everything because they're enormous. Um but the next prompt essentially says okay well if we're trying to import stuff where should we do that what's the start line and the end line. And so it says you know quite reasonably you should do that at line one that's where the imports go. 

And then uh this is interesting so we run reflection. So uh you have to assume every time you have a prompt it's going to go wrong at some point. So everything has some reflection running and actually says uh that first attempt at selecting the line ranges was wrong as instead of putting new imports at the top we should put them at the bottom of the existing imports which I think is quite smart. 

And then then what we do is we feed it. So this this is quite a neat prompt that maybe is worth showing. Um so there's lots of approaches to writing code with LLMs. Some people try to write diffs if you know what the unified diff format is. Unfortunately LLMs are really bad at writing that. 

And so what we do instead is we basically select a line range and then we say rewrite that entire line range in one go. So you can see that the code that gets out output in that step is. 

Share the AI Agent Store with friends.

Literally import new line another import and another import and so if we look at the change that was oh yeah and we run some reflection on this and it says yeah it's fine okay. 

So select for compare compare with selected and we can see this is the change that gets made and so I'm not going to show you every single iteration but basically you know let's see what it's doing next. 

So uh okay remove the existing code and manually conu the time stamp using local date and date time formatter and so if we compare again with the state after the next change fingers crossed will it work. 

So we got an import remember we did that change and then we've got oh beautiful look at that we got this new um datetime format with a pattern just like you would write in 2024 isn't that great and we've saved ourselves something like 20 lines of code and this is great we can do loads of different changes like this. 

There are limitations we can't like completely rewrite the program but if you know the change can be made within a 100 lines of code there's a pretty good chance that we can do it. 

Okay one example of 10 I'm just with you we got I've got one more example to show which is a slightly more complicated one and I'm not going to run it live because it takes about five minutes to run um but what we can do is maybe just look at the um the start and the end diff uh just to to show you like the the power of these models. 

So uh just to give you an idea of what the prompt is so when we in Cobalt ja uh Cobalt exception.

Handling wasn't invented. If you had to handle an error, you literally had to have a variable that is like did the file open or not. And then you just set it to like no if the file didn't open. And then somewhere else you would have a function that's like like 999 Abend. The program AB end is like abnormal end to the program. Um, so wouldn't it be nice if we could have like really beautiful Java exceptions everywhere? Throw a file exception if there has been some problem opening the file.

So again, uh, what we do is you know first the the llm decides okay let's create a file operation exception which seems pretty reasonable. Um, but the problem is you have to go in lots of different places and implement this. So we're stripping out all of these different random variables that are used for uh handling the error manually. We're throwing, we're we're trying, we're catching. Um, you can see later on there's lots of places where this file is used that we have to update. 

Um, and one of the interesting things that we see is that we sometimes get like compilation errors. So this is one of the big bits of feedback. Uh, so let me try and find an example of that. So this prompt here, so after every change what we're doing is running the Java compiler and saying are there any errors? And if there is an error then we feed it back to the llm. So you can see in this case after making these changes and compiling the the program I get this error how do we fix it? And it basically says I can't actually remember where we are but uh there we.

Go the error you need to remove so the the task list of tasks is very dynamic. We're not like saying so this is the fundamental mistake I think a lot of people building AI agents make is like you start with a big list of 10 things that you want to do. 

And the problem is as soon as you've done like task number two the toss list needs to change due to new information. And so all we're doing is saying at each point what do we need to do next based on information from the compiler from the unit tests that are running or from nothing at all cuz everything things fine. 

So we're not kind of trying to preempt too much what the task list is anyway. I think that's it. Um we're hiring. 

If you like compilers you've worked on lvm or the Russ compiler in the past come and work for us. If you like building llm agents come and work for us. That's all thank you very much. 

You want to answer a question? Yeah yeah yeah yeah I'll lots of questions go for it. Yes go. 

Yeah so so these main frames are pretty uh you know the reason they're still Legacy is because they're they're super critical systems. 80% of the time when you pay with with card that that transaction is being handled by your bank's Mainframe. 

So uh you know if we make a mistake like the financial system stops working essentially. So the stakes are pretty high and there some big fins that have been done. So testing is very important. We do blackbox testing at the moment. 

Um and most of the systems that we're dealing with are transactional so we have.

A history of 10 years in some cases of data inputs and outputs which we can back test on the updated system so that you know if you go to client and you say uh we can prove that there's 10 years of the same input and output they're quite confident with that. 

But that's not going to work for everything because some mainframes uh run UI based application. So when you go and check in for British Airways you may have seen behind the screen and it's like a black screen with green text. 

So that's much harder to test for. In that case we're using an llm uh based approach to generate unit tests um which is much harder to do. It's not 100% accurate but it's like much better than what's happening at the moment which is humans. 

So yeah cool all right. 

Note, that there may be slight differences in text and video. Watch video for the original content.

bloop AI Video