Programmatic Problem-solving

Not-so-technical intro

Anyone who has delved into computers has heard and probably experienced problematic programming when nothing seems to work in the script you spent hours writing and rewriting. But when all wrinkles have been ironed and this piece of software final works, it may be a source of value. This value stems from the fact that it (usually) solves some problems that would take longer to solve by hand, even if you had other powerful tools at your disposal (e.g., a spreadsheet program). So, what is it that makes programming a valuable aid in problem-solving, especially when things can get quantified and expressed in a way computers can understand? And how is that relevant to us these days? In this article, I'll attempt to answer these and other questions that may arise.
 

Problems, problems, problems…

There are various kinds of problems these days, particularly when complex processes are involved. As everything has become more interdependent (e.g., through globalization and other phenomena) problems become more complicated. This increased complexity is partly because many variables are now at play, making the solution space larger. In other words, many more potential solutions are possible, and finding a good one is like looking for a piece of straw in a needle factory! Notice that I wrote "a good one" instead of "the best one" as a good enough solution is often all we need. Of course, if we can find the best one, that's even better, but whether it's worth it is highly debatable.

For example, currently, we are using engines that aren't super efficient. That's fine, though, since we can still get value from them. If we had to wait until we solved all the scientific and engineering challenging of building a high-efficiency engine that's feasible to produce at scale, we'd still be living in the pre-industrial world!

Moreover, solving a problem often brings more problems to the forefront. When the brilliant engineers who developed the first digital computer during WW2 managed this feat, there appeared new problems that had to be solved to make it more widely applicable. After all, that computer would crack Axis codes and take up a lot of space, but if you wanted to do something else with it, you'd be disappointed. The first programmable computers that ensued were a big step forward, but they still lacked the elegance and portability that characterizes their descendants. Perhaps that's why finding the best possible solution isn't that big a problem if solving a problem well enough is our objective.

Algorithms as problem-solving tools

Once things got more advanced and computers evolved from problematic tools to problem-solving tools, things got much more interesting. After all, they made programming possible and the use of programming for tackling other, more challenging problems. But even before that, there was a tool that was used for this purpose which was known even to ancient Greeks (and probably other ancient cultures): algorithms.

Algorithms were once a strictly mathematical construct that helped the problem-solvers of the time tackle challenges that were unsolvable otherwise. In a nutshell, an algorithm is a series of steps that you need to follow to solve a particular problem. For common problems, you could leverage certain algorithms repeatedly, making their creators well-known. At the same time, Math would be more useful as a tool, something we observed ever since. Now, Mathematics wasn't just about measurements and basic calculations but also an elegant framework for modeling and solving problems that were unsolvable otherwise. Sometimes these algorithms gave rise to mathematical formulas and metrics that were then incorporated into the corpus of the field and are still taught in schools.

In computer science, algorithms play a crucial role since they are the most high-level form of software, particularly relating to programs used to tackle problems. Algorithms may have experienced a rebranding lately because of the AI renaissance we are going through. Yet they are a much wider domain, able to add value even without using those fancy frameworks AI entails. Algorithms are a powerful tool for all sorts of scenarios involving programming, from basic tasks like loading a data file and pinpointing potential errors that may arise, transforming data, and naturally, analyzing data. The latter task, in particular, has taken a life of its own through the field of Analytics, where algorithms seem to bring a lot of value. After all, data on its own is okay, but it's not valuable, much like a money token; on its own, it's cool (and in some cases nice to look at), but unless you can trade it with something you need, it's not all that important.

What about heuristics?

All this talk about algorithms may make someone wonder about heuristics since the latter is a powerful domain (framework?) that often involves leveraging algorithms for problem-solving. However, heuristics are geared more towards complex problems you wouldn't normally tackle with some standard algorithm or an algorithm you'd make up while studying programming. Before the advent of a certain kind of artificial neural network (a popular type of AI these days), image processing relied heavily on heuristics. One could argue that the whole field of digital imaging is based on certain algorithms that are heuristic in nature.

If you are wondering what all this has to do with you, remember that if these heuristic algorithms hadn't been developed, sending and receiving pictures on your mobile device would have still been science fiction. Not that you cannot have digital images otherwise, but if you want to have practical image formats like JPEG, you'll need to be smart about how you'd go about encoding visual information. And if you wish to do something useful with these images, conventional tools may not suffice. So, all this image-coding-and-processing matter is made possible through heuristics.

However, heuristics go beyond algorithms to help us in our problem-solving ventures. There are even elegant metrics that people have come up with and which have no theory behind them (though for some of them, like entropy, a lot of theory developed around them). Algorithmic heuristics are powerful for complex problems that involve iteration for finding a good solution, while they often involve a lot of programming. Metric-related heuristics are simpler and can be implemented even on a spreadsheet. However, when heuristics are combined with processes that programming brings to the table, they can be even more powerful.

Learn more about all this

I could go on talking about this topic for a while. If I were to do that, I'd probably end up writing a book on it (which I'm sure some of you would be eager to read!). Since I have already done that in the past year, to gather my experience and expertise on this subject in an easy-to-assimilate form, I'll just mention that book instead. It's called The Data Path Less Traveled, and it's my latest technical book through Technics Publications, a technical publisher from the US. Apart from the entertaining text, it also includes a few code notebooks so that you get to practice the concepts covered in an elegant, efficient, and empowering programming environment. So, check it out when you have a moment. Cheers!