AI-assisted software development: real today?

Antonio Alegria AI-assisted software development

Will AI replace software developers? Is AI-assisted software development real today?

We’re using AI for almost everything today … why not for software development? It’s probably not something that will replace developers, at least today. But it is something that could make software development easier and quicker

In this episode of The AI Show, we’re talking with Antonio Alegria, Head of AI at OutSystems. Our focus: a currently shipping AI-assisted development platform.

Listen: AI-assisted software development

Subscribe on your favorite podcasting platform:

Watch: AI-assisted software development

Subscribe to my YouTube channel to get notified when I go live in the future.

Read the full transcript: AI-assisted software development

John Koetsier:  Will AI replace software developers? Welcome to the AI Show with John Koetsier.  We’re using AI for almost everything today. Why not for software development? It’s probably not something that will replace developers, at least not today, but it is something that can make software development much easier and much quicker.

Today, we’re talking with Antonio Alegria, he’s the head of AI at OutSystems. Our focus is a currently shipping AI-assisted development platform. Welcome to the AI show!

Antonio Alegria: Hi John. Super happy to be here. Thank you for the invitation.

John Koetsier: Wonderful. Tell us, what did you build?

Antonio Alegria: So what we built is a, what we call an AI-assisted development capability that’s infused in our software development platform. OutSystem has a, what’s called a low code development platform, and we created an assistant that accelerates pros and helps novices learn by doing. It does that by understanding when developers are creating their logic and their application. Let’s say they’ve been creating some backend code or even the screen logic. We have an assistant that can tell them what is the one… the top three most likely things he or she will want to do next. So it presents the suggestions in line. It gives suggestions that are really specific to their own business logic and to their own software, including telling them that they should use a function that is unique to them, or a data entity that is unique to them. And then auto fills all of the variables and properties for them and tries to do that. So it really reduces the amount of options that developers need to consider at each step. It helps them create and develop with the best practices in mind. And if you think of an office, it really helps them learn while doing as well.

John Koetsier: Impressive. Talk to me a little bit about how long it takes to train that on perhaps a new programming language, development environment, and also perhaps the specifics of a project that a developer’s working on.

Antonio Alegria: Yeah, so this project we’re talking about is done in house at OutSystems. And so OutSystems has its own programming language. It’s a visual programming language so it’s a little bit different than what people are used to. So you actually have a visual way to design and define the logic in your applications and set variables and do if statements, but it’s pretty similar from a conceptual standpoint to your standard languages like C# and Java and whatnot, right? So the amount of time it takes to train, we’re talking about perhaps a day. We have over  15 million instances of these code pattern that we use to process it, and a lot of the complexity goes into not just training, but actually converting and managing and normalizing all of that data.

So this is not strictly tabular data or image data or text data, which you see in more standard  machine learning challenges. These are actually graphs … and a lot of the challenge comes from doing training over graphs and training deep learning networks over graphs, using graph neural networks. And so typically we deal with our own programming language and we’ve also been expanding more and more to the full domain of the programming language we have, currently this project is focused solely on the logic development language.

John Koetsier: Okay. So let’s get back to other languages in a little bit, but let’s talk about kind of your impetus for starting this project. Why did you start building this?

Antonio Alegria: Yeah, so OutSystems has one big goal, which is to enable all organizations to have extreme agility and to be able to innovate with no limits in terms of the digital transformation. So a lot of companies struggle to really keep up with the disruptors that go into the market. And a lot of companies have a lot of legacy. And so what our platform allows them to do is to really be able to create and develop software much more quickly than with traditional approaches. But what we see in the market still is that there’s a huge talent gap, right? And so a lot of CIOs and a lot of CTOs identify that they do not have enough people to really deliver on their projects. And although OutSystems already lowers the barrier for people without a computer science background to really deliver innovative software applications, we really think that we can take the leap forward on top of just improving the user experience of the developer tools or improving a programming language.

And so that’s where AI comes in. We believe that if we can embed an artificial tech lead inside the product that can automate, guide and validate developer’s work, we can really speed up the ability of organizations that do not have access to the top engineering talent in the market to really deliver the best solutions at scale.

John Koetsier: Interesting, interesting. Talk about some of the AI technologies that you used as you were building this yourself.

Antonio Alegria: Yeah, so as I said we work a lot with the graphs, and so one of the things we use most and which we’re conducting research as well, is on graph neural networks. And so these are essentially our algorithms, deep learning algorithms that are a little bit different than what people are used to in terms of processing images with convolutional neural networks or processing texts for NLP. So these networks shift a lot of the complexity in terms of when you’re designing and modeling the systems, not strictly on the architecture itself from deep learning, but on making sure that you’re modeling the data as best as possible in a very complete graph.

So we have built internal technology. One of them we call code X-ray, which goes into all of the data we have for the code, for a developer, for a team, for a project, and we really expand that to a much augmented graph. So we have data, not just from the structure of the code that developers see on their screen, but augment that with all of the data relationships, dependencies, data flow, all of that. So we really increase and enrich the context. Then we normalize these graphs, we try to follow the same standards, the same norms for a building code. Because some people, let’s say, write ifs in the positive, some write ifs in the negative. So we try to normalize for that. We try to identify bad practices and try to replace that with good practices and better practices.

And then we have these graph neural networks that we train to gain an understanding, a semantic understanding of code and try to understand this code that this developer did is trying to achieve more or less the same result as the other one. And so that helps us understand the context of what developers are doing. And with that, probabilistically we can understand what’s coming next in the next stage. So we also use TensorFlow just as a basic framework. A lot of Python, and one of the more interesting things from a technology standpoint that we use and that now is starting to become trendy, and I think we’re going to start hearing a lot about that coming soon, is hybrid … what now people are starting to call hybrid AI.

So we not only use deep learning, but we use more classical logic based AI systems, namely automated reasoning to really compliment the statistical and probabilistic and certain capabilities that deep learning brings. Because when you’re dealing with code, sometimes you really need to be certain and have some guarantees on what you’re proposing. Right? And so we’re using deep learning together with automated reasoning and these two compliment each other very well.

John Koetsier: Can you dive into that, how they compliment each other a little bit more? It sounds like you’re talking about some probabilistic models. You’re talking about some deterministic models, and there’s some things that you’re basically telling your application, ‘here’s kind of the hard parameters of the world.’ Is that accurate?

Antonio Alegria: Yeah. So, let me try to give you an example of how these two complement. So when you’re dealing with what I was talking about in terms of detecting, identifying some bad patterns, normalizing that. So that’s a thread we do and that’s part of the pipeline we work on. We use automated reasoning by configuring a set of constraints that configure or establish what a good pattern is in terms of code. It could be in terms of, you know, it’s bad for you to repeat your code. It’s bad to have duplicated code. And so we use automated reasoning which does not require you to label the data, and that’s one of the big advantages. You just need to, with the experts, you just kind of need to set what are the constraints, what are the things you value in code, and these systems then optimize and find what are the cases that match those constraints.

So for example, we might have a bad pattern, known bad patterns of code, but instead of writing empirically rules to detect them we just define the constraints. And then algorithms are able to very quickly, and these are all learnings that are really powerful, they very quickly can identify in the code base millions of patterns we see, what are those occurrences. And with that, we can see, okay, these are bad patterns we know, let’s just replace them with equivalent good patterns, for example.

John Koetsier: So how often do you need to look at those hard constraints? Do you need to look at those on a monthly basis or longer? ‘Cause some of those things might change, right? Some of those things are always going to be true in a language. Some of those things might change over time. What we once considered was a bad pattern might be a good pattern in the future. Is that accurate?

Antonio Alegria: Yeah. So we’re not yet at that stage. So we’re at the stage where we’re starting to build, we’re starting to encode all of the known patterns we’ve kind of created as a company, our experts, our architects that we provide to companies who try to code them as these constraints. But our vision and what we’re going to be doing this year and the next is we’re starting to use this capability, give them to companies as well for them to, for example, also introduce their own patterns by example. So they can say ‘Hey, this is something I don’t like. I think it doesn’t work well for my company and it’s just generic bad pattern.’ So then what we do is we use probabilistic models and graph representation models with deep learning to start getting a feedback loop of what patterns like this company and this company and that company identify. These are actually more or less the same. And then we have kind of a feedback loop system where we have experts looking at them and they can groom the examples. So our goal is to move from setting the constraints by hand, but providing these patterns by example.

John Koetsier: Nice.

Antonio Alegria: When we start having patterns being provided by example, we start creating a feedback loop and then with that you can build machine learning on top of that, and that’s where the real power comes in.

John Koetsier: Very cool.

Antonio Alegria: So we’re trying to build things for more scalably learning about code and learning about the qualities …

John Koetsier: Very cool, very cool. So as you look back at your project to date so far, what are some of the key challenges or problems that you faced as you’re building it out?

Antonio Alegria: Yeah, so interestingly, some of the biggest challenges we have are actually not strictly related with an AI. Although we are dealing with a very emerging area of AI, even in terms of processing graphs and code, and there’s a lot of challenges, but we have a great research team and collaborations with universities to drive that. But what we found is that sometimes we have the AI capability to do the right predictions with high accuracy, but it’s not always easy to find the best user experience to expose this in the product, especially when you’re dealing with probabilistic suggestions.

And especially when we were dealing with developers, and you have many different kinds of developers. You have the uber experts and you have the novices. Now the uber experts, they don’t really want you to change the way they work, and you really need to provide something that doesn’t get in their way.

But on the novice’s side you really want to give, handhold them through the paths. And there’s big, big challenges there. So for example, I was talking about the project where we’re applying these techniques to logic. So this is your backend code, but the UI is actually where people talk to us a lot about, they struggle with the UI, maybe doing the layout. Or how, what’s the best UI component to use? And we realize that’s a big opportunity and we believe that the capabilities we have could help there, but it’s still not clear to us what’s the best way to expose in the development platform assistance in that way.

So that’s one of the challenges. The way we solve it is by working really closely together with the product experience people, product designers, product managers. So they work together very closely with the research team, with the AI team, and we try as soon as possible as we have a baseline model to try to integrate it in the product. And start getting feedback, start experimenting with users, and that’s really powerful. Sometimes I’ve seen, I’ve worked in other companies where research teams doing this kind of AI work, they were for a long time isolated, and they ship a model. They hand it over to an engineering team, then re-implements it and deploys, and then it goes to the product. We have an integrated, a group that has a research engineering product design and everybody works together to just have a very agile feedback loop from research to product.

John Koetsier: That sounds a lot like what I’m hearing in a lot of different areas of how people are starting to work with these groups of people. We’ll have multi-disciplines who are all bringing their own expertise in. Let’s talk a little bit about the results. You must be seeing results as you’re measuring, as you’re going. What are you seeing in terms of development time, in terms of bug rate, in terms of efficiency and effectiveness of developers with the AI assist? Tell us about some of the results.

Antonio Alegria: Yeah, so the response has been really positive. I think so in this first phase of this project, in the program, we’ve been hearing a lot about developers saying that they can focus more on what they are trying to build because we reduce the cognitive load. So it allows them to kind of take a higher level view and thought about what they’re doing and what they’re going to do next. So that’s a big thing we’ve been hearing. Also a lot of developers stating that in a lot of tasks they can now accomplish things in seconds when it took them several minutes. So something that took them, let’s say five minutes, now they can achieve in 15 seconds, for example.

And this is not uniform. So we haven’t dropped the developments time yet for everything in order of magnitude, but for certain tasks we’ve definitely seen that. And curiously, we’ve seen developers saying and we have a user that told us that it’s actually helped them with repetitive strain injuries.

John Koetsier: I can see that.

Antonio Alegria: Yeah, because they had to move the … it’s a visual language so you use your mouse a lot. Drag and drop, and then you go to the keyboard to type stuff. And in many cases where the algorithms have learned specific patterns, you almost can just go, okay, next, next, next, next, next. And it’s, it’s very powerful.

Another thing we’ve seen from a results standpoint is that for novices in particular … so now we are allowing them to learn faster to reduce the friction points, because … so when you’re a novice and you’re exploring a very powerful platform, it’s very frequent where you get to a point where we call a ‘stuck moment’ where you aren’t really sure where to go next. And now with this assistant, you can really guide them in, say for example, a developer creates a screen for listing products. He or she has a button to scan, to search by a barcode, or search by image, right? Creates an action or creates a function for that.

Our algorithm has learned that a lot of the developers that want to do that, they use this library for scanning images and barcodes, and it helps them guide them through the process saying, okay, probably you want to use the camera to take a picture and then you want to check if the operation was successful. It also guides them through error correction and all of those things. So we’re definitely seeing not only improvements in speed in certain tasks, but also more relaxed for novices, a lesser degree of errors and code review turnaround time as well for technical teams.

John Koetsier: Interesting, interesting. So talk to us about the current status of the project and maybe talk a little bit about the next languages that you’re looking at.

Antonio Alegria: Yeah. So what we’re focused on right now, we’ve been shipping every week improvements to this capability I’ve been talking about. And we were expanding, mostly our focus is on expanding this investment in using AI to assist other areas of development process. And so what we’ve been focusing now is on the quality side of it. So not just, not strictly on speed, but on quality. And so using all of these capabilities I was talking about in terms of detecting bad patterns and bad practices. So what you’re going to see in the coming months is us embedding these capabilities where we will have a system to analyze all of your code, identify all of these bad practices, identify potential for refactoring, and then help you guide through that. And that is what is going to kick off that feedback we were talking about.

And in the development environment we’re also expanding these assistances not only to help you in the next step, but help you with the next pattern. So, okay, these are the 10 things you’re going to need next. Kind of expanding that to the next area. We’re also looking into how we can help in the UI. And one of the most interesting projects we’re starting right now is how we can focus more of these capabilities to help novices. So our perspective initially was to help novices by giving this assistance, suggestions. What we’ve seen  that novices really needed a little bit more context, a little bit more explanation and teaching, and we’re trying to see if we can identify and infer when they’re stuck, identify what they’re trying to do, perhaps provide them some help, some documentation, some guidance on what they need, and kind of tried to guide them through the process as well.

John Koetsier: Super interesting. I’m guessing you probably don’t want to be stuck as training wheels for novice developers, though. You also want to be building out tools for professionals and even the very expert developers. So when can people start to expect some of these capabilities in a language they’re currently using and love.

Antonio Alegria: Yeah. So that’s an interesting question. So in OutSystems, in the OutSystems platform, in language you really already have these two different groups. You have the novices, you have the OutSystems experts, right? And so as I said, the focus there is very different. I think as we embed more capabilities in the platform for suggesting patterns instead of next steps is very pro-oriented feature. The quality analysis capability is actually something that power users have been asking us a lot, especially as they work with other people in their companies that perhaps are not following the best practices. And we are also working on capabilities that deal with perhaps SQL, CSS, JavaScript that we have in our platform.

So we’re exploring and we’re doing partnerships with Carnegie Mellon University on how can we generate that code through examples. So let’s say you want to instead of writing a query, an SQL query, can you just say, ‘This is the input table, I want it to look like this’ right? We actually have

John Koetsier: I like that a lot. I suck at SQL, especially multi-table, multi-join type statements. That would be very interesting.

Antonio Alegria: Yeah. So, but in terms of expanding these capabilities to what we call high code languages like the C#s of the world and Javas. So that’s not really our focus because our focus is in the tools that our customers use. But there are other companies like Microsoft Research that’s doing a good job in visual studio and visual studio code. We sometimes keep in touch with them as well, and they’ve also shared with us the challenge of having to develop and test these capabilities with expert users as well, even inside Microsoft.

John Koetsier: Sure, sure. Okay, prognosticate a little bit for us … 3 to 5 years out, how influential is AI in software development and what does software development look like when it’s AI-assisted or even done by the AI?

Antonio Alegria: Yeah. So according to Gardner, for example, just give you a number. So they say and they predict that by 2022, 40% of all teams, all developer teams will have some kind of AI, an AI copilot as they call it. So as an AI component assisting them and the developer, and I actually  believe that in the next couple of years you will see probably every developer tool, every relevant developer tool will have some kind of AI assistance, at least in the sense of helping you guide to the next steps, auto-complete some of the things you’re doing, helping you in code review, and helping you in generating tests and perhaps adapting tests as you go. So these are kind of the main threads that we’re seeing.

Going five years ahead, what I think will happen is that these AI assistants will get more and more capable, so we start with AI systems that are more like an intern. They can just help you do some grunt work, some very uninteresting tasks. And what we’re trying to do is make these algorithms, make these capabilities more and more mature in the sense that they can then understand about architecture, understand about the high level semantic intent of the developer and start raising the instruction level. And what I think will happen is that a lot of the grunt work is going to be probably, if not completely, eliminated. It’s going to be automated in a big way. I think that will allow developers to focus more on the high level, more creative tasks, which is I think a dynamic you see with the AI introduction in pretty much all industries.

John Koetsier: Yeah that makes sense.

Antonio Alegria: There’s a big, I think a big driver as these things evolve. I mean, if you think about replacing developers, I think that’s a long way off because if you get to that point you actually achieved AGI in a sense.

John Koetsier: Yeah, perhaps.

Antonio Alegria: Yeah. So this could be a path towards AGI.

John Koetsier: Yeah. If we make AGI, we probably made many more things in software development  unnecessary. Well, thank you so much for joining us on the AI Show.

Antonio Alegria: Well, thank you for the invitation. It was a pleasure and I hope your audience enjoys this conversation as well.

John Koetsier: Wonderful. Yeah, and for everybody who’s joining us on the podcast  thank you.  Whatever platform you’re on, please like it, subscribe, share, comment  rate it and review it. Thanks so much. Until next time, this is John  Koetsier with the AI Show.

 

 


Want weekly updates? Of course you do …