On software job interviews: asking the right questions

Sometimes all it takes is a few buzzwords such as microservices, serverless, cloud, DevOps etc for us, software developers, to get excited when reading a job offer – we all like to work with the latest trends, tools and programming languages, but that is not enough if you you want to work on a good team with good practices. Who doesn’t dream about working for a company with a great culture and engineering practices such as Amazon, Microsoft, Facebook, Google or Netflix? I surely do!

One of the mistakes that some software developers do when applying for a new job is not trying to understand what is the level of quality of the current software team of the company you’re applying for – I confess I did that mistake in the past! The technologies might be cool but that doesn’t say much about the team and/or working culture. Just to give you an idea, I worked recently for a company that was using cool technologies but didn’t even have a build server when I started working there! Nor were they using any methodology such as SCRUM. Luckily things improved a bit but it took a while (too long, IMO) before that happened.

So if you want to evaluate the quality of a software team you need to make the right questions – but what are these questions? You might start with the Joel Test, which contains 12 yes-no questions to rate the quality of a software team:


Even though the original blog post was written on August, 2000 these questions are still very relevant in 2018, and this test is being used in StackOverflow Jobs portal (where I took the screenshot from), which contains some of the best software development job descriptions out there IMO. I’d love to see these test results in every single software development job description out there!

Other questions you might ask (some are related to Joel Test):

  • Which version control system do you use?
  • Do you write automated tests (unit tests, integration tests, etc)?
  • Do you use Continuous Integration/Continuous Delivery?
  • Do you do code reviews and/or pair programming?
  • Do you use design patterns/SOLID principles?
  • Which tools do you use?
  • Which methodologies do you use? SCRUM? Lean? Kanban? XP? Others?
  • Do you offer technical training to the team members or allow them to attend technical conferences?
  • Do you have technical meetings?
  • (Any other questions that might give you an idea about how the team works or is organised)

That’s it! Remember that a job interview works two ways:

  • A company wants to find the best candidate for a given position
  • A candidate (you!) wants to find the best company/team

So the interview it’s not only about answering some technical and HR questions, you need to ask the right questions about the company and working culture too. Don’t be afraid to prepare some sort of check-list containing some of the questions I mentioned above (and others that might be important to you) and ask them somewhere during the interview process – or, as an alternative, send an email asking someone (such as a team leader) to answer them. If it is a good company with good people I’m pretty sure they will get back to you!

This post is on how to rate the quality of a software team but there are many other questions you can (and should!) ask on an interview process – for example, take a look at  The Programmer’s Bill of Rights regarding working conditions for software developers.

Good luck!


Why I don’t pick up the phone

This happens to me all the time – recruiters trying to call me or sending me emails or messages on LinkedIn, telling me about a great role available and asking me if I’m available for a quick chat over the phone.


My answer is NO – I don’t want to have a quick chat with the recruiters over the phone, at least not at the very beginning of the recruitment process.

I don’t want to make recruiter’s life difficult, but I feel that most of the times it’s a complete waste of time (no offense) – mine and recruiter’s time. Why? Here are some of the reasons:

  1. I have no interest in new opportunities. This is quite obvious – if I’m not interested in new opportunities it makes no sense to have a chat over the phone. No need to waste time.
  2. There’s no concrete project. Recruiters need to add profiles to their systems/databases and many times they will call candidates even if there is no opportunity available at the moment. Please don’t waste my time, send me an email when there is a concrete project and we’ll talk about it.
  3. I want to save the message for future reference. This is one of the most important reasons for not wanting to pick up the phone – it’s impossible to remember most or all the details for each role that recruiters send! Having an email with a job spec and other details such as benefits, salary, etc makes my life easier.
  4. I want to have some time to analyse the role. “What do you think, Rui?” – over the phone there is more pressure to give a yes-or-no response, at the moment. Having an email with the description of the role/company/etc means I can take a look at it when I have some spare time, and take my time to analyse it and even do some research about the company, etc and then decide if it is of interest or not.
  5. Role doesn’t match my profile. Sad but true – I receive many messages from recruiters regarding roles that have absolutely nothing to do with my profile! Java, PHP or Python opportunities? QA roles? Sysadmin roles? Network engineer roles? Seriously? I’m a .NET software engineer!
  6. Role is of no interest. Even if the role do match my profile, it doesn’t mean it is an interesting one. For example, I have absolutely no interest in support roles or roles that use old/obsolete technologies.
  7. Location is of no interest. There is a shortage of IT candidates with good experience, so recruiters will try to find talent everywhere, not only within their local recruitment market. I get messages from not only European but also other countries such as the United States! Most of the people won’t be available to move to other cities or countries without a very good reason.
  8. I’m at work. Recruiters need to get in touch with potential candidates and many times they will call during working time, but if I’m working I cannot (or shouldn’t) pick up the phone 3 or 4 times a day to talk with a recruiter – I have work to do. Also, that wouldn’t be very professional, don’t you think? And a complete lack of respect to my current employer. Just leave me an email and I’ll get back to you.

I believe there are many other IT guys like me that feel the same way about this. Let me say it again – I don’t want to make a recruiter’s life difficult, I just want to avoid wasting time (mine and theirs).

So, ideally a recruiter will send an email or LinkedIn message with a good job description (containing a quick description of the company, location, industry, summary of the role, responsibilities, skills and experience, salary, …) such as this one I saw on jobserve.com:

If the role is of interest then yes! I will be available for a chat over the phone, to ask for more details or clarify any doubt 🙂

The Bug Cap

I’ve just watched the Agile at Microsoft video, that shows how the Visual Studio Team Services (VSTS) team at Microsoft adopted an Agile mindset and culture. The whole video is interesting but there was one item in particular that caught my eye, which is named the Bug Cap.

The Bug Cap is a simple strategy to keep the bug count low, in order to preserve the software quality. In other words, if your bug count exceeds your bug cap you stop working on new features until you’re back under the cap.

This is the formula suggested by the VSTS Team to calculate the bug cap:

For example, having 5 engineers in one team the bug cap would be:

5 X 5 = 25

Let’s suppose that the bug count at some stage is 30 – this means that the team should stop working on new features until the bug count is less than 25.

This is a very simplistic rule but I guess this is a good starting point in order to limit the number of bugs per sprint and avoid chaos. I guess you can try it with different formulas as well, such as multiplying per 3 or 4 – whatever works for you 🙂

You can watch the whole video here (the bug cap topic starts around 00:29:01):


On smoke tests

So you have configured a new build for your ASP.NET application: the source code compiles without errors, there are no unit tests failing, the deployment package is generated and published as an artifact – great! Now it’s time to deploy it. Everything seems to be fine (no errors logged), but when you try to run your application you get an YSOD like this one:

There are many things that can go wrong with a deployment, so it is important to configure your deployment pipeline to verify that the deployment itself was successful. You can do it by using smoke tests.

Continue reading

We don’t have time for unit tests

This is probably one of the biggest bullsh*ts people usually tell in the world of software development:


I’ve heard it many times before, and I bet you’ve heard it too. I was unfortunate enough to work for companies where PMs and other people had this mentality, even giving the impression that unit tests were a waste of time. “Just do it quick and dirty” – this was a very common sentence in one of the last companies I worked for.

A lot has been written about unit tests in the last 15 or 20 years, and the advantages should be obvious by now – you can refactor your code with confidence without the fear of breaking existing functionality, you can run unit tests as part of an automated build, and so on.

But there are disadvantages as well – you do need to spend some time to write the test and debug the piece of functionality you’re testing, as obvious. This is usually the excuse given for NOT writing unit tests. But the truth is that we need to test the functionality somehow – it’s not acceptable to write a piece of code without testing it, right? You simply have to test your code, one way or another – even if you don’t use unit tests.

That leaves me with another question – from a development perspective, do you think that the alternatives ways to test your code are faster than writing a unit test? I don’t think so. I still believe that unit testing is the fastest way to do it, if you have a decent enough experience with it (you don’t need to be an expert, though). Let’s analyse the following scenario below.

The scenario – discount calculator

Imagine that you are working on an e-commerce website – the UI is an ASP.NET website that uses a REST API (ASP.NET Web API), where all the business logic is. You need to implement a discount calculator in the API, based on the customer type:

  • Platinum (20% discount)
  • Gold (10% discount)
  • Silver (5% discount)
  • Standard (no discount)

Source code would be something like this:

public interface IDiscountCalculator
    decimal Calculate(decimal productPrice, CustomerType customerType);

public enum CustomerType
    Standard = 0,
    Silver = 1,
    Gold = 2,
    Platinum = 3

So let’s examine some of the different ways we could test the discount functionality.

1. Testing using the UI (website)

In this scenario you basically need to run the website and the API, and navigate to the page where the discount is being displayed (e.g. view shopping cart). This means that you might eventually need to login, search for a product, add it to the shopping cart and then view the shopping cart in order to check if the discount is correct or not. Also, you need to do it for each customer type.

As you can imagine, this is not the most efficient way to test this functionality. We need to compile and run both the website and the REST API (authenticate user, etc).

2. Testing the API using a REST client

This is more efficient compared to the previous example (testing the UI) because you can skip all the steps mentioned before and invoke the service using a REST client such as Postman or SoapUI. You still need to create sample HTTP requests that might include HTTP headers (content type, authorization, etc), HTTP method and message body (JSON request object).

Depending on the service, it might take a while to configure the requests for each customer type. Also, we need to compile and run the REST API. Remember that in this scenario all we want to do is to calculate the discount for each customer type.

3. Testing using a console application

This is one of the simplest ways to run the test. There’s no need to use the UI to get to the page where the discount is displayed and there’s no need to create HTTP requests in order to invoke the API, i.e. we can test directly the discount functionality using .NET code. Also, console applications are faster to compile and run compared to an ASP.NET website.

4. Testing using an unit test framework

It’s basically as simple and fast as creating a console application – just add add your unit tests to a class library and you’ll be able to run the tests in a few seconds, using Visual Studio built-in functionality or a tool such as Resharper.


Saying “we don’t have time for unit tests” is deceiving. Giving that we need to to test our code somehow, ask yourself if the alternative to unit tests is easier and/or faster (creating a sample console app to run some tests, etc) – I’m pretty sure that in most of the cases the unit testing is the better option.

Deploying an Azure WebJob via VSTS without deleting existing WebJobs

The scenario:
I have an Azure App Service that is hosting 5 different WebJobs. I have configured a release on Visual Studio Team Services (VSTS) to deploy each WebJob to Azure, independently from each other.

The problem:
Deploying a WebJob deletes the other WebJobs that were already deployed!!!

Tick the “Set DoNotDelete flag” – current files/folders in the App Service in will be preserved while publishing website.


Re-throwing exceptions without losing the original stack strace in .NET

This is nothing new – if you need to re-throw an exception in a catch block without losing the stack trace you use the throw statement like this:
01 throwThings are a bit different outside a catch block, though. Consider the following code sample:

Just to give you some context, this excerpt is from a MessageHandler that I implemented to log HTTP requests and responses in a ASP.NET Web API application (based on Log message Request and Response in ASP.NET WebAPI). I have an ExceptionHandler class that will log all unhandled exceptions, that’s why I’m re-throwing the exception here.

The problem is that the following command will instantiate a new exception and clear the original stack trace:

throw exception;

Fortunately there is an easy fix. From .NET v4.5 you can use ExceptionDispatchInfo class to capture the current state of an exception and re-throw an exception without changing the original stack-trace:

That’s it! Happy coding 🙂

When to create a Nuget stable release?

I was having a chat with another member of my team this morning about Nuget package versioning – the question was the following:

When should we create a stable release version of a NuGet package? 

I found the answer in Building pre-release packages: a stable release is one that’s considered reliable enough to be used in production. It’s just as simple as that. Also, keep in mind that the latest stable release is also the one that will be installed as a package update or during package restore:


For more details please go to Building pre-release packages (package versioning, pre-release versions, reinstalling and updating packages, etc).

Disabling ‘member is obsolete’ warnings on Visual Studio Team Services

The scenario – I am working on a new functionality solution that has many members marked as Obsolete (some are not being used at the moment and others will be removed in the future). When the solution is compiled warnings are being generated as follows:

And this is how things are supposed to work – other developers working in the same solution will know straight away that these members should not be used. It’s perfectly fine to diplay these warnings locally, but honestly I don’t think it makes sense to display them on the build server.

MSbuild has a property named nowarn that can be used to suppress compiler warnings. In my case, I want to suppress warnings CS0612 (‘member’ is obsolete) and CS0618 (‘member’ is obsolete: ‘text’).

In VSTS add the following to the MSBuild arguments to your Visual Studio Build task:



That’s it! No more ‘member’ is obsolete warnings will be displayed when running a new build. Remember to add the same arguments to other tasks that might use MSBuild (for example, I have another task that generates an ASP.NET deployment package which was generating the same warnings).

Happy coding!

Testing Service Fabric deployment packages on VSTS

The scenario – you have a Service Fabric build configured on Visual Studio Team Services (VSTS) as follows:


As you can see from the screenshot, there is a task to generate the Service Fabric deployment package. There were no errors in this task, but don’t assume that everything is OK with the package, something might go wrong when you try to deploy it to a SF cluster.

In order to avoid surprises when deploying the application, you can test the package after its generation using the Test-ServiceFabricApplicationPackage powershell cmdlet.

Add a new Powershell++ task after generating the package and configure it as follows:

The command takes the path to the SF package folder as a parameter. I usually set the SF project as the working folder.

Queuing a new build, you can see the results of the build and in particular the task that tests the SF package:


That’s it! With this solution you will know immediately if something is wrong with the package, saving you from the frustration of a failed deployment. This doesn’t mean that deployments will never fail, but hopefully you will be able to detect most or all of the errors in the deployment package every time you trigger a new build 🙂