Viva64

The Shortest Crashing C Program

Fri, 24 May 2013 15:15:02 -0400

It might seem like a strange idea to want to write a small crashing C program, but in one of the courses that I’ve been teaching labs this is one of the tasks! It’s actually a very educational thing to do.

The Hazards of Remembering Positions in Vectors

Fri, 24 May 2013 15:10:35 -0400

The Hazards of Remembering Positions in Vectors:

Don’t remember pointers, references, or iterators to vector elements until  you’re done putting new elements in the vector.

Abstract: Using static analysis tools for automating code...

Fri, 24 May 2013 14:54:02 -0400

Abstract: Using static analysis tools for automating code inspections can be beneficial for software engineers. Such tools can make finding bugs, or software defects, faster and cheaper than manual inspections. Despite the benefits of using static analysis tools to find bugs, research suggests that these tools are underused. In this paper, we investigate why developers are not widely using static analysis tools and how current tools could potentially be improved. We conducted interviews with 20 developers and found that although all of our participants felt that use is beneficial, false positives and the way in which the warnings are presented, among other things, are barriers to use. We discuss several implications of these results, such as the need for an interactive mechanism to help developers fix defects.

Article: http://www4.ncsu.edu/~bijohnso/ICSE2013.pdf

Why Don’t Software Developers Use Static Analysis Tools to Find Bugs?

Fri, 24 May 2013 14:50:43 -0400

Why Don’t Software Developers Use Static Analysis Tools to Find Bugs?:

C/C++ Low Level Curriculum Part 12: Multiple Inheritance

Thu, 23 May 2013 14:32:25 -0400

C/C++ Low Level Curriculum Part 12: Multiple Inheritance:

Hello, and welcome to the 12th part of the C / C++ low level curriculum. Really soon after part 11! (No, of course part 11 didn’t get too big and need to be split. Why would you ask?)

Why I'm Trying Literate Programming

Thu, 23 May 2013 14:31:21 -0400

Why I'm Trying Literate Programming:

I decided to experiment with literate programming recently because I felt like something must be wrong with this story: A colleague and I began a research project using MATLAB for a class. We both started with about the same amount of MATLAB experience: close to nil. We both started at the ground floor of development. There was no legacy code to speak of, and again there was only two of us. We spec’d out most of the simulation as a LaTeX document that clearly described the simulation mathematically based on a reference implementation. In my mind, there isn’t a better scenario for collaboration. However, late into the project, my colleague was getting shut out of participating in development. What shut my colleague out?

CPP SUBREDDIT. Discussions, articles and news about the C++

Tue, 21 May 2013 15:52:20 -0400

CPP SUBREDDIT. Discussions, articles and news about the C++:

Discussions, articles and news about the C++ programming language or programming in C++.

C++ exceptions under the hood

Tue, 21 May 2013 15:41:45 -0400

C++ exceptions under the hood:

Our latest personality function knows whether it can handle an exception or not (assuming there is only one catch statement per try block and assuming no inheritance is used) but to make this knowledge useful, we have first to check if the exception we can handle matches the exception being thrown. Let’s try to do this.

A perspective: developers vs Microsoft

Sun, 19 May 2013 16:42:56 -0400

A perspective: developers vs Microsoft:

Most people understand that Windows is used by a variety of people who have a variety of needs, ranging from corporate server to workstation to POS terminals to home PC and beyond. Most people accept that whenever Microsoft updates Windows, it has to balance the competing requirements to find some kind of workable compromise. There is however another set of competing requirements that many do not really register, even those that call themselves power users or are IT admins. It is a conflict between developers/programmers and Microsoft itself.

Problems with TDD

Sun, 19 May 2013 07:10:38 -0400

Problems with TDD:

If you have not yet read it, please read Maria Siniaalto’s 15 page “Test-Driven Development: empirical body of evidence.” It summarizes the few empirical studies done to evaluate the effectiveness of TDD. In the conclusion you’ll find:

Based on the findings of the existing studies, it can be concluded that TDD seems to improve software quality, especially when employed in an industrial context. The findings were not so obvious in the semi-industrial or academic context, but none of those studies reported on decreased quality either. The productivity effects of TDD were not very obvious, and the results vary regardless of the context of the study. However, there were indications that TDD does not necessarily decrease the developer productivity or extend the project lead-times: In some cases, significant productivity improvements were achieved with TDD while only two out of thirteen studies reported on decreased productivity. However, in both of those studies the quality was improved.

Easy C/C++ Source Code Analysis with Visual CppDepend

Sun, 19 May 2013 06:46:14 -0400

Easy C/C++ Source Code Analysis with Visual CppDepend:

http://www.sobbayi.com/blog/software-development/easy-cc-source-code-analysis-visual-cppdepend/

For the past few weeks I have been quite busy working on a couple of things which involve quite a lot of coding. I had gotten myself a copy of CppDepend and knew this was the time to put it through the trenches. CppDepend is a static code analysis application that simplifies managing very complex C/C++ code through analysis of the code dependencies on Windows through visualization and the use of CQL (Code Query Language).

Free Static Code Analysis with Eclipse

Sun, 19 May 2013 06:10:40 -0400

Free Static Code Analysis with Eclipse:

I know for myself: the earlier I’m able to fix a bug, the better. So I’m always grateful for things which help me to find issues in my sources as early in the development process as possible. Eclipse and CodeWarrior already help me to find syntax errors in my code while I’m typing:

An eternal question of timing

Sat, 18 May 2013 13:57:39 -0400

An eternal question of timing:

It seemed that long forum debates about methods of measuring algorithm’s running time, functions to use and precision that should be expected were over. Unfortunately, we have to return to this question once again. Today we will discuss the question how we should measure speed of a parallel algorithm.

I want to say right away that I will not give you a concrete recipe. I myself have faced the issue of measuring parallel algorithms’ speed only recently, so I am not an expert in this question. So, this post is rather a research article. I will appreciate if you share your opinions and recommendations with me. I think we will manage the problem together and make out an optimal solution.

4GB per Vector

Thu, 16 May 2013 15:19:18 -0400

4GB per Vector:

I recently had a problem where I had a vector that was growing once, being iterated over once, and then deallocated. And it was bothering me how much time I spent on reallocating. The problem was that I also could not predict well how big the vector would be ahead of time. It could vary by orders of magnitude for input that looked similar at first.

Coroutines in C++

Thu, 16 May 2013 15:13:41 -0400

Coroutines in C++:

An ideal subroutine is a mathematical function; it takes inputs and returns the results of its computation. It has a single entry point and all data local to it is initialized upon entry and cleaned up when it returns to the caller. The next call, if any, starts all over again and no local residues are carried over from the last invocation. A coroutine, is an interesting deviation from these conventions. It can yield control back to the caller as soon as there are partial results that can be put to use. Moreover, when invoked again, it can resume the computation from where it left. These yield/resume semantics make coroutines a better unit of structuring programs for certain types of problems.

An Interview with Bjarne Stroustrup (May 15, 2013)

Thu, 16 May 2013 15:10:38 -0400

An Interview with Bjarne Stroustrup (May 15, 2013):

Danny Kalev talks to Bjarne Stroustrup, C++ creator and author of of The C++ Programming Language, fourth edition, about the impact of C++11, why he doesn’t consider the job of a programming language to be secure, his thoughts on garbage collection, and what’s coming in C++14.

Empty list initialization

Thu, 16 May 2013 15:07:29 -0400

Empty list initialization:

Did you already try using the new initialization syntax with STL containers? This works as you might have expected: The above initialization works because the constructs use the new initializer-lis…

C++11: Iterating range-based for backwards

Thu, 16 May 2013 15:04:46 -0400

C++11: Iterating range-based for backwards:

A few weeks ago we upgraded our toolchain with spangly new C++ compilers. Then we flipped the magical switch unleashing C++11 code features. This is a joyful apocalypse.

It’s been fun transitioning to some of the new neater C++11 idioms.

Range-based for is one of the first things we adopted, largely due to the clear readability improvements it brings over tedious iterator type juggling.

JSON Spirit: A C++ JSON Parser/Generator Implemented with Boost Spirit

Thu, 16 May 2013 15:01:33 -0400

JSON Spirit: A C++ JSON Parser/Generator Implemented with Boost Spirit:

JSON is a text file format similar to XML, but less verbose. It has been called “XML lite”. This article describes JSON Spirit, a C++ library that reads and writes JSON files or streams. It is written using the Boost Spirit parser generator. If you are already using Boost, you can use JSON Spirit without any additional dependencies.

OpenGL 101: Drawing primitives - points, lines and triangles

Thu, 16 May 2013 14:59:37 -0400

OpenGL 101: Drawing primitives - points, lines and triangles:

This is the second article from my OpenGL 101 series. In the first article we’ve seen how to open a window for our OpenGL application with the GLFW library and how to compile and run the code on Windows, OS X and Linux. It is time to actually draw something using OpenGL.