Static analysis is a method that one can use in order to analyze, understand, and assess the quality of a program. The main strength of static analysis is the pinpointing of coding errors without the execution of a program. In this blog post, we discuss how static analysis can contribute to the evaluation of the existing exceptions of a program and how static analysis can help in the prediction of possibly thrown exceptions by a program.
By now, America’s STEM problem – the growing gap between demand and skill in American jobs in STEM fields – is well recognized (see this commentary by Bill Nye). One source of the problem is a lack of interest in the sciences and mathematics among young Americans that begins at an early age. Continue reading
The execution of a program can suddenly terminate for several reasons. To prevent unexpected program behaviors, developers can include error handling mechanisms in their programs. Specifically, in Java, developers can use two types of exceptions: checked and unchecked. Checked exceptions (IOException, DataFormatException, ParseException, SQLExceptions, etc.) are always caught on compile time, whereas unchecked exceptions (OutOfMemoryError, ArithmeticException, NullPointerException, IllegalArgumentException, IllegalStateException, etc.) can occur on runtime and lead a program to an unexpected termination (crash)—if there is no prevention mechanism in the source code to caught the exception. However, there is a debate regarding the use of the unchecked exceptions in the source code (see Unchecked Exceptions — The Controversy, in the Java documentation).
In my previous post, I briefly mentioned that if the execution order of iterations in a loop can be altered without affecting the result, it is possible to parallelize the loop. In this post, we will take a look at why this is the case, i.e., how is execution order related to parallelism. Moreover, we will see how this idea can be further exploited to optimize code for data locality, i.e., how can reordering of loop iterations result in using the same data (temporally or spatially) as much as possible, in order to efficiently utilize the memory hierarchy. Continue reading
In a world driven by technology, there has been an emerging movement devoted to teaching kids how to program early on. As mentioned in my last post, teaching kids computer science in K-8 education has many benefits. But one problem is that there aren’t many tools out there that are able to teach computer science effectively for young students at affordable prices. The Wyss educational robotics team at Harvard sought to solve this problem.
Given the fact that security bugs are critical, one of the basic pursuits in every new software release should be to mitigate such bugs. In essence, security bugs should decrease as a project evolves. In a previous post I described how I measured the occurrence of security bugs through time and observed that security bugs actually increase as projects evolve. However, the corresponding experiment involved only four projects.
Mobile devices have become an indispensable part of our everyday lives, mastering our on-line transactions and influencing our communication with others. However, most smartphone users experience application crashes once in a while. A crash manifests when, for example, you are using your favorite application and it suddenly stops working properly or closes. Sometimes, this can be really troublesome, especially when you try to send an important message or proceed with a financial transaction. There are many reasons that can lead mobile applications to crashes—and the causes are not always tractable. This blog entry discusses the causes of application crashes in mobile devices, based on the examination of a corpus of crash reports from Android applications .
Technology has such a ubiquitous role in the world that kids are starting to use it at the age of two. These are, or rather will be, the so-called Digital Natives. These infant natives teach their grandparents how to use their iPads and iPhones with ease. This demonstrates how plastic the brain is during early stages of development. And if they are capable of using and teaching technology, kids are capable of understanding technology. Yet for many students, their first experiences in formal computer science classes begin in high school – if they’re lucky. So why do we open up the world of technology to kids at such an early age but not enable them to truly learn about it for years? It would be beneficial to education and society for schools to implement computer science curricula in K-8 education.
“I really wish I had a dedicated Linux computer to run computer vision algorithms on,” said my fiancée a couple of weeks ago. If you were there you would have been blinded by the metaphorical light bulb that lit over my head. You see, just the week before, my friend and co-worker had ordered an old, decommissioned (complete with “non-classified” stickers!) Apple Xserve off of eBay for merely $40. Like my fiancée, he wanted to have a machine for a special purpose: test compilations of open source software on a big-endian architecture. I was quite envious that he was able to hack on such cool hardware for such a cheap price. But, I wasn’t yet ready to bring out my wallet. I couldn’t justify indulging a new hobby without good reason—I was stuck waiting for just the right impetus. I didn’t wait long. My fiancée’s wish became my command!
“As soon as an Analytical Engine exists, it will necessarily guide the future course of the science. Whenever any result is sought by its aid, the question will then arise — by what course of calculation can these results be arrived at by the machine in the shortest time?”
Charles Babbage (1864)
Points to Ponder
Would it not be wonderful, if we could write all our simulations as serial programs, and parallelized code (highly optimized for any given supercomputer) would be generated automatically by the compiler? Why is this not the case today? How come supercomputing centers require teams of highly trained developers to write simulations?
Scientists around the world develop mathematical models and write simulations to understand systems in nature. In many cases, simulation performance becomes an issue either as datasets (problem size) get larger, and/or when higher accuracy is required. In order to resolve the performance issues, parallel processing resources can be utilized. Since a large number of these simulations are developed using high level tools such as Matlab, Mathematica, Octave, etc., the obvious choice for the scientist is to use the parallel processing functions provided within the tool. A case in point is the
parfor function in Matlab, which executes iterations of a for-loop in parallel. However, when an automation tool fails to parallelize a for-loop, it can be hard to understand why parallelization failed, and how one might change the code to help the tool with parallelization. Continue reading