We do write complex software, and like everyone doing so, we need a way to structure our source code. Our choice was to go modular. A module is a singleton that defines a feature or a set of related feature and exposes some APIs in order for other modules to access these features. Everything else, including the details of the implementation, is private. Examples of modules are the RPC layer, the threading library, the query engine of a database, the authentication engine, … Then, we can compose the various daemons of our application by including the corresponding modules and their dependencies.
Read more
Jeez! It’s been a year already! A year working at Intersec… Time goes by so quickly! A year ago, I was thinking about giving up the idea of appending “PhD” to my name: I quit the graduate program I was in after only 10 months. Before that I had been working for a year at this other company called… wait! Was it Intersec already? Oh my God! It was!
Intersec? Really? Is that even a name? Could it be possible that some guy picked such an unsexy name for his company? This is the first train of thought that went through my brain after ending my nth phone conversation with a head hunter. An interview was scheduled a couple of days later.
Read more
Back in 2009, Snow Leopard was quite an exciting OS X release. It
didn’t focus on new user-visible features but instead introduced a
handful of low level technologies. Two of those technologies
Grand Central Dispatch (a.k.a. GCD)
and OpenCL
were designed to help developers benefit from the new computing power
of modern computer architectures: multicore processors for the former
and GPUs for the latter.
Alongside the GCD engine came a C language extension called
blocks.
Blocks are the C-based flavor of what is commonly called
a closure:
a callable object that captures the context in which it was created.
The syntax for blocks is very similar to the one used for functions,
with the exception that the pointer star is * replaced by
a caret ^. This allows inline definition of callbacks which
often can help improving the readability of the code.
This series of articles describes some of the best realisations made by Intersec R&D team during the 2-day Hackathon that took place on the 3rd and 4th of July.
The goal had been set a day or two prior to the beginning of the hackathon: we were hoping to make Gerrit better at recommending relevant reviewers for a given commit. To those who haven’t heard of it, Gerrit is a web-based code review system. It is a nifty Google-backed open-source project evolving amid an active community of users. We have been using this product here at Intersec since 2011 and some famous software projects also rely heavily on it for their development process.
Read more
The most used custom allocators at Intersec are the FIFO and the Stack
allocators, detailed in
a previous article.
The stack allocator is extremely convenient, thanks to the
t_scope macro, and the FIFO is well fitted to some of our use
cases, such as inter-process communication. It is thus important for these
allocators to be optimized extensively.
We are two interns at Intersec, and our objective for this 6 week
internship was to optimize these allocators as far as possible. Optimizing
an allocator can have several meanings: it can be in terms of memory overhead,
resistance to contention, performance… As the FIFO allocator is designed to work
in single threaded environments, and the t_stack is thread local,
we will only cover performance and memory overhead.
This series of articles describes some of the best realisations made by Intersec R&D team during the 2-day Hackathon that took place on the 3rd and 4th of July.
As testers, we spend a lot of time working on
behave, our test automation
framework1.
Our test framework is a great tool, but it takes a lot of time starting
and initializing the product, running tests one by one.
Telecom data is a rich source of information for many purposes, ranging from urban planning (Toole et al., 2012), human mobility patterns (Ficek and Kencl, 2012; Gambs et al., 2011), points of interest detection (Vieira et al., 2010), epidemic spread modeling (Lima et al., 2013), community detection (Morales et al., 2013) disaster planning (Pulse, 2013) and social interactions (Eagle et al., 2013).
One common task for these applications is to identify dense areas where many users stay for a significant time (activity zones), the regions relaying theses activity zones (transit zones) as well as the interaction between identified activity zones. Thus, in the present article we will identify activity and transit zones to monitor and predict the activity levels in the telecom operators network based on the SMS and calls input/output activity levels issued from the Telecom Italia Big Data Challenge. The results of the present study could be directly applied to:
Read more
In the third post of the memory series, we briefly explained locality and why it is an important principle to keep in mind while developing a memory-intensive program. This new post is going to be more concrete and explains what actually happens behind the scene in a very simple example.
This post is a follow-up to a recent interview with a (brilliant) candidate1. As a subsidiary question, we resented him with the following two structure definitions:
Read more
Here we are! We spent 4 articles explaining what memory is, how to deal with it and what are the kind of problems you can expect from it. Even the best developers write bugs. A commonly accepted estimation seems to be around of few tens of bugs per thousand of lines of code, which is definitely quite huge. As a consequence, even if you proficiently mastered all the concepts covered by our articles, you’ll still probably have a few memory-related bugs.
Read more
malloc() not the one-size-fits-all allocatormalloc() is extremely convenient because it is generic.
It does not make any assumptions about the context of the allocation and the
deallocation. Such allocators may just follow each other, or be
separated by a whole job execution. They may take place in the same
thread, or not… Since it is generic, each allocation is different from
each other, meaning that long term allocations share the same pool as
short term ones.