<img height="1" width="1" style="display:none;" alt="" src="https://dc.ads.linkedin.com/collect/?pid=46809&amp;fmt=gif">

CommonTime Enterprise Mobility Blog

[Podcast] The Lego Analogy in Software Development

In the third edition of the CommonTime podcast, we discuss a common analogy in software development - the comparison between low-code development platforms and Lego. It's a much loved analogy in our office, with multiple boxes of Lego across every floor.

Over the course of 15 minutes, our team discuss what makes the comparison so important and the flexibility that we have aimed to build into the CommonTime Infinity platform. We also take a look at some common objections to the low-code model of app development and how some of those can be overcome.

Chris: Hello and welcome to the third edition of the CommonTime podcast.  Today I'm joined by Andy, Ben, Matt and Richard. We're going to be talking about the Lego analogy. And this is the Lego analogy for software development. So, Andy would you like to introduce this?

Andy: I would love to. So, the Lego analogy was the perfect excuse to get a whole bunch of Lego Technic models for the office. But, with a hopefully legitimate reason. I want to  talk about what we do, and how we're able to align ourselves to what Lego are very good at doing.

So, when you buy a Lego model you are buying the promise of the ability to make whatever is on the front cover of the box. But, you've got to do the bits yourself. What it gives you are all of the tools, some instructions and then you're required to put the effort in to make the model.

With the CommonTime Infinity platform, we're realised that we also have been providing all of the tools and end 'picture' which you can make. We also recognised some of the things Lego are very good at. It's been at much mirth that we've come across this, but what Lego are extremely good at are giving you moments of gratification along the way.

We've got a range of very simple 18 page models, to absolute monsters which are 400 pages long and take a couple of weeks to get to the end. As you are going through that build process, you are given moments where you can actively see something working. At these moments you go 'Wow' and that's also what we hope to provide with CommonTime Infinity.

Matt: I think there's more of them with the larger builds. Because, for instance, it reminds me of that big Mercedes truck where you get to build an engine. It introduces the concept of components.

Andy: Abslolutely.

Matt: And we know the Infinity platform uses web components (the new standard) to build functionality which you can port across to other apps should you choose. 

Andy: Shameless plug time... We're talking there about the ES6 standard of web components which slot perfectly into the CommonTime Infinity platform. Again, taking the Lego analogy that little bit further: Lego were the original (40 years old this year) and best at modular building. However there are others who have done it as well.

So you've got Megablocks, Brixio and supermarket varients of the same thing. The great thing is that they are all intercompatible. If you need to get a particular color and size of brick that you can't get from Lego, which is almost impossible, you know you would be able to get it from one of those other providers. In the same way, if you need something in the studio which you can't get out of the lists that we provide, you can use your own - which then becomes portable. And it's not just portable in the studio; it can then be incorporated into your website or other development projects you may have.

Matt: The other nice aspect of the Lego analogy that I like is the realisation that the instructions have absolutely no words. They are understandable by anybody with a pair of eyes - which leads into intern...int... it's nice. If I could say it, it would be beautiful. Internationalisation. Though I prefer the little four letter acronym or whatever it is.

Chris: I8N.

Matt: That's it. So, it's not a very good analogy at all but from a developer's point of view, the drap and drop interface means it has a low entry to understanding. Building up functionality in the app is about as intuitive as it could possibly be.

Andy: It's app centric, in the same way that Lego is model centric. Your end goal is based around the model that you are making. When you are doing that within the studio, you are looking to add more into the application. And Technica are brilliant at this - you'll typically build a structure, which is an underlying chassis. Then you'll put on the engine; the working components, gearing that goes with it. Ultimately you'll add some garnish with stickers to make it look pretty as well. 

If you were to look at what we can do with Infinity, you are building up a very similar model base by adding elements to the application. You're then adding Java and scripts as the gearing and more complex aspects. Ultimately you're using good old SCC to add frills and garnish around the outside. It's another multi-stage process. But on the outside, without the frills, you can still see that what you've got works. You can spin it on one side and see the ladder extend on the other. It's just nice to have that ability - hence the Lego analogy.

Ben: And you get the reassurance as well that if you get a four piece block, it will fit to another four piece block and a six piece block. You get the confidence that Lego have done the hard work (effectively) in ensuring these bits and pieces will fit together. You know you're going to get that consistency. If you compare that to software, CTI specifically, you get nice pre-tested components which reduce the development cycle. I think, again that's a very strong feature for a platform like CTI. 

Andy: Absolutely - especially if you look at your testing effort. We don't know what you're going to build with the big bucket of Lego. Someone could build a plane, someone else could build a boat and someone else could build a space station. We don't know in advance what will be built. All we need to know is that the bits which go together to make that up (the wings of the palne, the side of the space station and the solar panels) have already been tested for you. All you need to do is test it in contxt. It does make iut a lot easier from a development perspective.

Chris: Is it fair to say that there's a point around creativity as well - that you can come in with an idea in mind & build it, or take the instructions someone else has put together to build that, or play around & understand contextually how the pieces fit together?

Matt: Yeah, I think that final point is important. Some of the examples I've seen in Infinity are really quite trivial to reverse engineer. It's not reverse engineering, it's having functionality that you would want in your own app and finding something to look at.

Clearly, if you look at the source from the designer - you can see how that's been put together and instantly understand how you could take that further or change it. That's taking a Lego brick out and putting another colour in, if that's all you want. It's trivial to see and understand how to do that - and I think that is exciting. My perception is that it's quite a creative environment. 

Andy: But equally, with that ability, I could put that down and someone else could pick it up and understand what they may need to do next if they are following some instructions, or at least understand (because of the way it has been built) what they could do to further extend it. Again, that goes back to your base Lego model. You follow the instructions and then you think "Now what can I do?" That's where it starts to become really exciting.

Can I take the lights off and add something else? Can I add steering? Can I add power functions to that? It may not be me who wants to do that, it may be someone else. But because it has been built in a very consistent way, it's very easy for someone else to pick up and alkter.

Ben: As well, it's fair to say that with something like Lego you don't need to worry about ease of use. Take Mecano to compare it against. With Mecano you need more of an understanding around detailed engineering; bolting things together - that kind of thing. You also need more of an understanding about structure.

Whereas with Lego, you can play and spend more of your developers efforts thinking of novel and creative ways of solving problems - rather than the detailed mechanics of how you're going to get something working. In a .NET platform, you would need to spend a lot more of your time at a very low level. Something like this allows you to get up and running straight away. Worse still, in my mind, would be something like Sticklebricks where you can never line anything up.

Matt: You can never make it look nice... Oh, and that was the other thing I wanted to say, just to be balanced. We should say how Infinity is not a tool like Lego. I've never trodden on it and hurt myself... ever. 

Andy: That's true. I've never sucked Infinity up into the vaccumm and broken it.

Matt: And I've never shoved a piece of CommonTime Infinity up my nose. Yet.

Chris: So something that a few people may think is that Lego allows you to build whatever you want. However when thinking about low-code drap and drap app development platforms, there is a view that some people has which is; they can be quite a limiting environment. Is that true for CommonTime Infinity?

Andy: You are only limited by your, and I have to say it because I always say it, your technology and your imagination. Your technology isn't going to stop you - it's extensible. Your imagination is the only thing that's going to stop you. 

Matt: There's always going to be that perceived tension when you have a GUI led platform. As long as it's clear what the GUI is doing to the developer, and the developer can remove that layer as he or she wishes, then it's not a restriction. It really isn't.

Richard: No, because that's where the web components come in. You can make absolutely anything into a web component, which lives can live outside the studio completely. So it can be, as Andy said earlier, something that is on a website or elsewhere. That is your custom Lego model that you've had built that coincidentally fits into into Lego pieces.

Matt: And back-end wise, calls to whatever APIs you want to create yourself can either consumer public keys or one you create yourself. You've got the basis there of being able to achieve whatever you want to achieve.

Andy: We badge it as a low-code development platform. And at a very superficial level, it is. However, what we also provide is the ability to lift the bonnet, to get in there and get amognst the workings so you can make it do what you want it to do. I guess that's why a low-code platform is a bit of a misnomer for it. That's only superficially what it can do, but in reality it is much more.

Richard: It's an 'as low-code as you choose' platform rather than low-code. If you don't want to use any of the built in components at all, you don't have to. It would be like going through your lorry build without looking at the instructions at all, so that you can build a gigantic lorry which turns into a Transformer. And you can.Or you can just follow instructions one through eighteen to build something quite good quite quickly.

Andy: But a lot of the common problems that developers have around building UI, connectivity to other things such as APIs and databases have been solved in CTI. They're the kind of things that people do day after day, project after project. That kind of functionality is helpful.

Matt: You don't have to be a Lego master builder to get those results.

Chris: So, I think that brings us quite nicely to the end of the podcast. Just to wrap up; the crux of this discussion is really about building something in Lego (or blocks) is better than sculpting it by hand - custom development. Really quickly, to finish on, why is building something using the blocks in CommonTime Infinity better than custom development?

Andy: Quicker, cheaper, more reliable. 

Matt: And the hard edges, once you find them after you've blocked it up - a prototype if you like - you can go in and remove those hard edges by refining a web component that doesn't work quite as you want or building a new one.

Ben: Shorter development cycle. You get better investment.. You get it out there, and people using it. No-one likes testing. 

Matt: Get those results back into another iteration....

Chris: Great - thank you everybody for joining me today and for talking about Lego for the last 15 minutes. Hope you enjoyed it! And thank you to everybody listening as well, and we hope to see you again next time.

Posted by Chris Martin

Chris is a digital marketer who strongly believes in the power of creating memorable customer experiences. He proactively drives digital strategy and content production at CommonTime.