July 8, 2019

A Look at Iterator Traits

  —The Iterator Category Trait.

I took the opportunity to develop a patch Boost::Utility to address bug 13002. I concluded:

The compiler error in the reproducer occurs because std::set does not provide a random access iterator.

Absolutely correct. And terribly short-sighted.

I didn’t think this was a bug because C++ doesn’t require support for the expression r += n, unless the object supports a random access iterator. This lack of support for this expression causes the compilation error reported in stl_iterator.h.

std::set doesn’t provide a random access iterator. It provides a bidirectional iterator. Same for std::list. std::vector provides a random access iterator.

Even the tests supported my thinking. But the tests were insufficient and I wasn’t aware of bug 10847.

I wish I could say I authored this patch. I didn’t. Here is the most relevant parts (full commit).

template< typename T >
struct is_iterator
    typedef char yes_type;
    typedef char (&no_type)[2];

    template< typename U >
    static yes_type check_iterator_category(typename U::iterator_category*);
    template< typename U >
    static no_type check_iterator_category(...);

    static BOOST_CONSTEXPR_OR_CONST bool value = sizeof(is_iterator< T >::BOOST_NESTED_TEMPLATE check_iterator_category< T >(0)) == sizeof(yes_type);

Important components:

template< typename T, typename Distance, bool IsIterator = is_iterator< T >::value >
struct next_advance_impl :
    public next_plus_assign_impl< T, Distance >
template< typename T, typename Distance, bool IsIterator = is_iterator< T >::value >
struct prior_advance_impl :
    public prior_minus_assign_impl< T, Distance >

Very cool.

I was wrong about the direction to take this patch because I didn’t look through the bug database to see if there were other open tickets against boost::next() and boost::prior().

On the bright side because someone authored bug 13002 I was able to participate in the improvement of Boost!

June 15, 2019

Bad Behaviour Online

  —We’ve failed to realize the Internet’s promise of cooperation and communication.

In Giving Up More Than You Realize with Twitter (Part 2), I discuss how ill-considered Tweets were career ending for the people involved. Regardless of how you feel about the rightness or wrongness of their Tweets it’s astonishing how much abuse those people recieved.

In What causes good people to turn bad online?, Gala Vince writes:

There is overwhelming evidence that women and members of ethnic minority groups are disproportionately the target of Twitter abuse.

Nothing new here.

While we generally conduct our real-life interactions with strangers politely and respectfully, online we can be horrible. How can we relearn the collaborative techniques that enabled us to find common ground and thrive as a species?

Good question.

Gala’s thesis is that we’ve failed to realize the Internet’s promise of cooperation and communication. We’ve failed to realize this promise because being online reduces our need to cooperate.

She goes on to say social media has weak institutions (or rules) and that there are few reputational or punitive risks for bad behaviour. Essentially, people don’t have a set of rules to govern their behaviour and the consequences of doing so are virtually non-existent.

There is also evidence that moral and emotional words are more likely to spread on social media. Content that triggers outrage is likely to trigger more outrage and be shared.

The article goes on to say that social media platforms might benefit from providing people with control over who they connect too. The idea appears to be that you start with an open network and then disconnect from people you don’t like. Not sure how that’s going to work out given that its counter-intuitive to the notion of the promise of cooperation and communication.

A better idea discussed in the article is to add some sort of reputational cost in the form of a social punishment. This seems closer to real life, but doesn’t address the problem that an algoritm needs to be designed to do this.

I like the promise and the notion that cooperation and reputation are missing. Hopefully, we don’t us a broken notion of reputation like the Black Mirror Nosedive episode (Series 3, Episode 1).

June 9, 2019

GDB Steps Over Functions

  —A brain-fart using gdb, but a common one.

I recently had occasion to debug some code in Boost.Regex. Boost.Regex is a really well written Boost library that was a pleasure to read.

I got burned initially when debugging Boost.Regex because I had forgotten that it includes a library, so when I tried to use GDB to step into a library function it stepped over it. The solutin, of course was to recompile the library to support debugging.

The surprising thing about this is that I initially tried solving this issue by Googling for “stepping over template” and got a surprising number of hits related to optimization flags. I wonder how many of those problems were because the template had been compiled into a library…

May 17, 2019

Structured Data for Search

  —Introducing Structured Data to my blog.

I was reviewing Search Engine Optimization and came across a post from Paul D’Ambra on adding Structured Data to a Jekyll blog. Super helpful.

It provides pointer on how to add Structured Data to your home page and blog posts.

I had a bit of trouble with with the home page description, but solved it using Carousels. Pay particular attention to the markup in the examples.

The blogListElement.html component is missing from Paul’s article. I provide an implementation below that the Structured Data Testing Tool reports as ok. The schema is different and I couldn’t get it to pass to tool without these changes.

Importantly, Paul’s implementation provides articles in reverse chronological order, so the most recent come first. This is probably what you want from a Carousel.

I was able to use Paul’s blog post implementation. Some modifications to include keywords, license and copyright.

(I also safely say that Paul’s blog is more authoritative than mine. Having read his blog, mine is now authoritative for being unread.)

May 11, 2019

Code Reviews

  —Developing a shared resource through code review.

In, Code Reviews I discuss my philosphy on code reviews. In this arcticle I wanted to highlight something written by Sam Jarman in Giving and Receiving Great Code Reviews.

Sam states that a code review is:

Code review is a time to discuss and debate code that is going to be owned by the team going forward. A member, or members of the team will write the code, and the rest of the team, or a subset will determine if it’s at a standard such that’ll be a good value add to the codebase./

Essentially, the rest of the team determines if the code is at a standard such that it will be a good value to add to the codebase. Simply, the best description of purpose for code review that I have read.

I like this definition because it introduces

  • the notion that the code base is a shared resource used by the team to accomplish something and that as a shared resource all (or potentially all) team members can have a say in what is added to this resource.
  • some many good notions regarding what an effective team should care about: shared ownership, common standards and best practices.
  • the notion of interaction–discuss and debate the quality of the patch.