We often think of complexity as something to avoid, but we don’t have to be afraid of complexity. As we’ve been doing homework, we’ve been learning the most efficient way of sorting two arrays of objects that we’ve created. We have to think about this in terms of complexity, and that complexity is the space complexity.
The way we take objects to create their own patterns is a big one, and it’s definitely a big thing that our designers have not been aware of. We’ve been doing the same thing, and we’ve been doing it right the right way too.
The problem is that our code is very simplistic. The space complexity of the code is extremely low, so when a developer wants to sort two arrays of objects, the best he can do is put them in a “camelCase” style. That is to say, to sort two arrays of objects “a” and “b”, they can sort them by “a.b.
CamelCase is basically a way to make code that is easier to read, and easier to optimize. It makes code easier to understand and easier to optimize because you have a short-hand to describe the entire code, and thus can optimize it. As it turns out, this is a big deal, because there is a tendency in some codebases to be too verbose. Weve made our code as simple as possible, but still maintain some space complexity because space complexity is very important.
To make code as easy to read, we have a space complexity to keep it as concise as possible. We have a space complexity to keep it as small as possible, because the complexity of the code is important. We have a space complexity to make it easy to optimize it, because the optimization is important. In short, we have a space complexity to make our code as easy to read and as small as possible.
It’s true that code is often easier to read when it’s simple. But it’s also true that code is often harder to optimize when it’s complex. Sometimes that complexity can be hidden behind a complex interface. There are other times, especially if the complexity is really well hidden, that it can be hard to optimize.
quicksort provides a space complexity to make our code as simple to read as possible. Its true that code is often simpler to read when it is simple. But its also true that code is often harder to optimize when it is complex. Sometimes that complexity can be hidden behind a complex interface. It is a tradeoff between readability and optimization. Sometimes a simple interface can hide a very complicated and very complex interface. Sometimes it can be difficult to optimize a very simple interface.
In the example above, I am sorting a list of strings by the first 3 characters of the string, but the complexity is probably hidden behind a complicated interface somewhere. But really, we are sorting a list of strings by the first 3 characters of the string, but the complexity here could be hidden in the complex interface somewhere.
The other examples show that we’re not really in a position to optimize the complexity of our UI to get a few more things to work. The UI is not optimized for UI complexity. In fact, we’re just using one UI for a long time as a way to optimize our UI. So if you want to make a UI that looks like this, check out this post.
The other thing I like about this video is that it’s very, very difficult to understand what’s going on there. In the video, you can actually see the complexity of the interface as it’s sorting the strings. If you don’t understand the interface, then you can’t understand what’s going on.
