The Winning Tech Resume

Tech jobs across the world are rapidly increasing and can be found in most industries. The rise of such jobs is due to organizations increasingly relying on computer systems and technologies. 

Examples are the adoption of cloud computing and cybersecurity. As a result, employment in IT occupations is predicted to increase by up to 12% between 2014 and 2024. 

Some specialized tech jobs that are expected to increase in demand include:

  • Software developers
  • Web developers
  • Information security analysts
  • Mobile application developers
  • Computer system analysts

These jobs will require you to have specific skills that you will have learned and practiced. Some of the most important IT skills you may already possess are:

  • Coding
  • Application development
  • Cloud services
  • Cybersecurity
  • Database administration

Combined with the below ‘soft’ skills, you will be able to fit into a tech role of your choice. 

  • Communication skills
  • Time and project management skills
  • Analytical skills
  • Problem-solving skills

These are the basics that will enable you to work within an IT department, as well as interact with high-level management. 

Note: Though the terms are interchangeable, do not confuse tech skills and technical skills. Tech skills relate to IT skills associated with digital technology. Technical skills are a broader range of abilities, such as accounting which is not a tech skill.

Each type of tech resume needs to be tailored to the role and this is the tricky part for job seekers in the industry. 

You will need to be able to showcase your specific skills. At the same time, you need to differentiate yourself from people with similar skills and highlight relevant experience. 

How do you make your resume stand out among the thousands that employers receive? 

This guide will give you an overview of what to consider when creating a tech resume that will get you hired. 

Once you have an impressive resume, the next step is to find jobs to apply for.

By targeting employers who are looking for someone just like you, there is a better chance to be called in for an interview.

Using the Quantic platform is an ideal solution to finding new opportunities. The platform is specifically designed to connect students with top employers and every job seeker has a chance at success.

This is why we have developed sample resumes for the most popular tech jobs. Just like we did for data analysts

The format of your resume is also an important factor as employers only take a few minutes to skim each CV. 

Let us help you create a winning resume and take the first step towards landing your dream job.

What Makes a Good Tech Resume?

Several features that make for a good tech resume. Let’s look at 4 of the top tips.

Use the Correct Format

Structure Your Resume in Reverse Chronological Order

You need to start with your most recent job – the pinnacle of your career. After this, list all the relevant previous jobs in reverse order. 

This will draw attention to your growth path and act as a way of putting your best foot forward. 

Use Professional Fonts and Spacing

The top three fonts to use are Calibri, Cambria, and Helvetica; being the neatest and most legible. The size can be either 12 or 10 in order to be legible and headings can be either size 12 or 14.

With regards to spacing, stick with single-line spacing.

Set the Correct Margins

You don’t want to cram your resume with text as it will look unprofessional. Large margins on the other hand make it look empty. Your best option is to use one-inch margins on all sides.

Use the Correct Format – Word vs PDF?

Firstly, read the job description and follow the employer’s instructions. Send whichever format they specify and send their preferred format.

If there are no specifications, usually a PDF document is a safe choice. It will preserve your formatting and open as a professional-looking document.

One disadvantage is if the recruiter is using an applicant tracking system, (ATS). The software may have trouble scanning your CV and skip crucial information.

If unsure, you can show some initiative and reach out to the hiring manager and enquire about their preferred format. Alternatively, simply send CVs in both formats. 

Proofread Your Resume

Take the time to ensure 100% correct spelling, grammar, and formatting. Sloppy mistakes on your CV are a sure-fire way to demonstrate to your potential employers that you don’t have attention to detail.

Highlight Your Strong Points

To avoid sending a generic resume, you will need to address the needs of the company. 

To do this showcase your skills at the top of your resume. Pay close attention to the necessary skills listed on the job posting and match your strong points to the advertised position.

This is one of the tricks to creating a successful tech resume that will get you into the interview room.

Write an Engaging Experience Section

The work experience section is probably the most important part of a tech resume. Employers know what you did by looking at the job title. They are more interested in how you well did it. 

This section will be proof that you can perform the technical skills you have described. 

To make your experience section engaging, follow these tips:

  • Make use of bullet points
  • Use short, descriptive sentences 
  • Prove your experience with links to your previous work or portfolio 
  • Include the duties and responsibilities of the jobs you provide

Write According to Your Experience Level

Those with extensive experience have very different CVs compared to recent graduates.

For an expert, their education level is not going to be a deciding factor. They can simply write:

2011 – 2015

Stanford University

B.Sc., Software Engineering

This section should be placed directly under your career statement. 

For those without an extensive work history, place your degree and learning institution below your education level. This means your education section will be more detailed, like so:

2011 – 2015

Stanford University

B.Sc., Software Engineering

  • Chairperson of IT-Hub, the campus machine learning club, 2014 – 2015.
  • Completed eight advanced Java programming classes to cement my knowledge.
  • Broadcasted an online webinar on best practices for security in cloud services.
  • Wrote for the S.U. Mag, specializing in IT-related topics on a monthly basis.

Use Sentences That Get Straight to the Point

Do not use overly-long sentences when writing your resume. You want to keep the sentences short, and preferably in bullet point form. Here are some tips when writing the bullet points; 

  • Start with an action verb: Oversaw 
  • Describe a specific task: Software upgrading campaign 
  • Complete with a quantifiable point: Cost reduction of 10% 

The final sentence will read:

Oversaw a software upgrading campaign that resulted in a cost reduction of 10%. 

Your resume should also get straight to the point. 

“I want to be able to quickly glance at a resume and make sure they meet the criteria for the level of position I’m looking for and then if they do, I’ll read their resume more closely,” Melissa Wallace, Talent Acquisition Partner 

Because most tech jobs are results-oriented, provide context on how you have used the skill to achieve results. 

Use metrics to quantify your success. Using percentages is a great way to quantify your abilities. 

Some bullet points to quantify your results could be: 

  • Achieved X results in Y amount of time. 
  • Reduced costs by X amount using XYZ software. 
  • Ensured X customer queries were resolved using XYZ methods. 

You should also include details of your skill level. Are you a beginner or an expert? Mention this along with each skill. 

If you don’t, the recruiter may find your CV to be lacking and assume you do not have the correct qualifications. 

You also don’t want a resume that is too long, and tiresome to read. However, do not leave out important information; striking a balance is key. 

How Is a Tech Resume Different From Other Industries

All tech jobs require very specific skill sets and in addition, many companies are looking for a well-rounded individual. 

You need to have a section assigned where you can list your skills. Make a table and include it just after the experience section of your resume. 

Some of the major skills for the most popular tech jobs include: 

IT Technician

  • Front and back end development 
  • Cloud computing 
  • Network structure and security 

Software Engineer

  • Programming languages 
  • Databases 
  • Encryption and cryptography 

Web Developer

  • Website design 
  • Digital advertising 
  • Mobile and social marketing 

Data Analyst

  • Data analysis and exploration 
  • Creating dashboards and reports 
  • Statistical knowledge 

Data Scientist

  • Probability and statistics 
  • Multivariate calculus and linear algebra 
  • Programming packages and software 

Product Manager

  • User experience (UX) design 
  • Data understanding and analytics 
  • Product engineering 

A Winning Tech Resume Template

There are some major things that you must include in your tech resume. 

Some of these include;

  • Contact Information: Include your name, professional title, phone number, email, LinkedIn handle, and personal portfolio, blog, or website.
  • Career Summary: A short introduction that highlights your career progress and specific skill set. It should only be a few lines and encourage the employer to read the rest of your resume.
  • Experience Section: Up to six bullet points describing the roles and responsibilities of your previous jobs.
  • Education: List your schools and degrees achieved, as well as the corresponding years. Include honors and awards, and if you are fresh from school, you can add your GPA grade. Under this section, you can include certifications and professional memberships as well as achievements and awards.
  • Skills: Use our tips to create a skills section to grab the reader’s attention. Even if creating a tech resume, some skills are desirable across the board. Here are a few:

– Leadership

– Teamwork

– Research

– Analytical thinking

  • Optional Sections: If you have space, create a hobbies and interests section. It should reflect your personality and fit in with the company culture.

To stand out, show that you have enough business acumen to perform high-level jobs. You need to be able to manage teams of technicians and communicate with high-level management.

Studying a solid, certified MBA program is a great addition to your job-specific skills and will help you go up a level – especially in the eyes of the employer.

A free Quantic MBA has been developed by leading professors to create a comprehensive 9-course curriculum.

Once completed, the areas covered will earn you a DEAC accredited degree. Some of these include:

  • Accounting and finance
  • Data and decisions
  • Markets and economics
  • Marketing
  • Strategy development and entrepreneurship

Want to Get Hired in Tech?

Quantic’s students only have good things to say, but as a tech worker, you may have some doubts about delving into the business world.

You can rest easy and be sure you are making the right decision, just like Front-end Engineer, Robin Lu.

And that dream job, won’t just land on your lap. You will need to spend time and possible money getting your resume to the right recruiter.

As a Quantic student, you will be able to apply to exclusive positions in your chosen field. 

The Quantic Talent platform gives you access to recruiters who are looking for Software Engineers, Data Scientists, Product Managers, UX/UI Designers, and more at top tech companies.

MBA for Software Engineers – Do You Need One to Climb the Career Ladder?

You’ve been a software engineer for years, and you feel it’s now time to take a step forward. But you’re wondering: What comes next? Where do I go from here? 

What catches your attention is that other software engineers are going for an MBA. As a result, they’re getting promotions and enjoying fatter paychecks. But is this the road you want to take? How will earning an MBA increase your chances of climbing the software engineer career ladder?

If this is you, we understand. We know it can be difficult to decide on the next step in your career. That’s why we’ve put together this guide specifically for you. In it we cover:

  • The career ladder of a software engineer (from bottom to top)
  • How an MBA can help you climb that ladder 
  • The different types of MBAs, and how to choose one to match your needs

When you finish reading this, you’ll know exactly where you want to go next in your career and whether or not an MBA will help you get there. Let’s dive in! 

Understanding the Software Engineer Career Path

To know where you want to go on the software engineer career path, you first need to decide what your biggest priority is. Is it to gain a bigger salary? Or is it to keep doing what you love, but on a larger scale?

Think of it like this. The higher you move up on the career ladder, the less you’ll be getting your hands dirty doing the work of actual programming. Some are happy with a lifetime of writing code and fixing bugs. Others want to go into managing complex software systems, and others want to manage teams. 

To make a good decision on where you want to go, it’s important to go into detail on the typical software engineer’s career path.

The Software Engineer Career Ladder

You start as a software engineer, but it’s not uncommon for you to move to the top with a C-suite job. 

Here’s what the career ladder of a software engineer looks like. We’ll start with the first rung on the ladder, junior software engineer, and go all the way to the highest rung, CTO. In between, you’ll see the different steps in the ladder and how each one requires its own set of more complex skills and responsibilities. 

Junior Software Engineer

Junior software engineers are mainly responsible for building quality software. This includes writing code, fixing small bugs, and working closely with senior developers on pair programming. 

The junior software engineer role is an entry-level position. The skills required are what you already have: knowledge of programming languages, operating systems, and databases. As you gain experience, you’ll start handling larger projects and working more independently. 

Senior Software Engineer 

Senior software engineers still write code, but this time with an eye on the bigger picture of a project. They’re in charge of designing and developing software solutions, plus coaching other developers. This is an excellent position for those who love programming but don’t like the idea of leading a team. 

The skills needed for this position are basic software architecture, advanced code design, and coaching. 

Lead Developer 

Lead developers still write code while coordinating work and implementing decisions. Other programmers usually look to them for direction. This position is seen as a transition into a mid-level management role. 

Technical Architect 

Technical architects rarely write code. Their main responsibilities lie in designing complex systems that other developers create. Going for the technical architect position is the biggest leap you can make as a software engineer without going into leadership and management roles. 

Development Team Lead or Software Development Manager 

Mid-level managers are in charge of overseeing either projects or teams. Depending on their leadership skills, their job can include:

  • Managing complex projects
  • Coordinating between higher management and development teams
  • Hiring and firing developers 

Besides the technical skills required for this position, mid-level managers need excellent people skills. 

Chief Technology Officer (CTO) 

Chief Technology Officer (or CTO) is the highest-ranking position in the IT business. The role of a CTO is to oversee all of the company’s technological needs. CTOs have executive powers they can use to make decisions and investments for the advancement of the company. 

The Career Path for a Software Engineer After Earning an MBA

How far up you want to go on the software engineer career ladder is up to you. Some professionals stay at the senior engineer level their whole lives (and love it!) while others progress to CTO. It all depends on what you love doing most, whether that’s writing code, managing projects, or handling relationships between people. 

If your dream is to get into leadership and management roles, getting an MBA makes sense. Here’s why. 

MBA for IT Professionals: Why It Makes Sense 

Of course, strong technical skills are a must if you want to climb the software engineer career ladder. However, they aren’t enough to get you to the position of CTO. This is because companies today are looking to hire executive officers who have both excellent technical skills plus strong business acumen.

Think of yourself in the position of hiring a new CTO for your company. The first applicant has strong technical IT skills and years of experience as a software engineer. The second one has all these, plus the ability to see the bigger picture and understand how technical decisions will impact the company’s finances and business outlook. Who do you think you will hire? 

If you already have years of experience developing software and the next logical step for you is to go into C-level management, an MBA can help you acquire the skills to fit into this position. 

Is an MBA for Information Technology Worth It?

Earning an MBA can cost upwards of $200,000. If you stop working while pursuing your studies, this amount can rise up to $400,000. 

To determine if an MBA is worth the cost, you first need to ask yourself some important questions.

  • What do you plan to do with your MBA?
  • Where do you see yourself five years after completing your MBA?
  • How long will it take you to achieve significant ROI from your MBA?

Why Do Software Engineers Pursue an MBA?

Here are six reasons software engineers pursue an MBA despite the heavy cost. 

  • Respect from business-side teams
  • Promotion to management roles 
  • Salary increase (up to $44,000 per year) 
  • Better chances of being hired as CTO in a new company
  • Greater confidence working in managerial positions 
  • Career satisfaction from being able to climb the corporate ladder

MBA Software Engineer Salary Statistics

In general, professionals with an MBA earn more than those without one. In the U.S., MBA holders earn an average of $102,100. That’s higher than the national average of $74,378

But it gets even better for IT professionals with an MBA. According to U.S. News, technology is one of the top three fields that pay the highest salaries for MBA holders. 

According to PayScale, a software engineer with an MBA earns an average of $119,438. That’s $44,906 larger than the average salary of software engineers, which is $74,532.

An MBA for Software Engineers

Understanding the different types of MBAs is essential for mapping out your career direction. Here are three to consider. 

  • Campus-Based MBA. Requires you to stop working and focus on earning your MBA on campus. Best for new graduates who have the time and financial stability to support themselves in school.
  • Online MBA. Allows students to continue working while they earn their MBA.
  • EMBA. Designed for professionals with many years of experience, the executive MBA is for people who want to advance their careers and move into senior leadership positions in their companies.

The Best MBA for Software Engineers

Use this as a guide to select the MBA that’s right for you. 

Executive MBA for IT Professionals 

If you are an IT professional looking to climb the career ladder into senior leadership, the best program for you would be an executive MBA. 

An EMBA is different from an MBA mainly because of its focus. While MBAs are designed for new graduates, EMBAs are for professionals with years’ worth of experience looking to showcase their business credibility and advance their careers. 

The qualifications for EMBA are also different from those of a regular MBA. While qualifying for a regular MBA requires top-notch academic scores, getting into an EMBA program requires a look into professional working experience and skills. 

MBA Career Network for Tech Professionals

Since 80% of positions are filled through networking, it’s an excellent idea to look into programs that offer exposure to other top-notch professionals. Knowing great people will not only widen your chances of professional growth, but also challenge you to grow and sharpen your skills. 

What’s great about joining a career network is that you can connect with thousands of the brightest minds around the world. You get access to current students, alumni, plus the chance to get discovered and hired by excellent tech companies.  

MBA Course Curriculum for Software Engineers

Before selecting an MBA program, it’s essential to look into the curriculum to see if it includes these four aspects.

  • Business. To lead in a C-suite position, it’s important to understand the core concepts of business, finance, and marketing.
  • Strategy. In a management position, you’ll be in charge of top-level strategy so it’s important to find an MBA that covers this.
  • Decision Making. IT professionals should be able to understand how to make critical business decisions based on data.
  • Leadership. Since leading a team will be one of your duties, acquiring communication and interpersonal skills is a must. 

MBA for Software Engineer Discussions on Reddit

Going through other professionals’ different experiences and opinions will help you weigh out the pros and cons of getting an MBA and make your decision. One great way to do it is to read Reddit threads on the topic

Believe it or not, Reddit is an open community and discussion forum that’s influential among higher education students. Here you can ask, find specific questions from other software engineers, and get answers and suggestions from those who are in the same field and have earned their MBA. 

Summary: Should You Get an MBA? 

Getting an MBA is not for everyone. To determine whether it’s right for you, you first need to consider your priorities and where you want to go on the software engineering path.

If writing code is what you want to do all your life and you have no interest in managing a team, getting an MBA might not be the best fit for your needs. However, if you have your sights set on mid-level management or even CTO, earning one will give you the knowledge and credentials to get there. 

Git Bisect Debugging with Feature Branches

Inspectocat, courtsey of GitHub
Inspectocat, courtesy of GitHub

At Pedago, we follow the GitHub Flow model of software development. Changes to our app are made in feature branches, which are discussed, tested, code reviewed, and merged into master before deploying to staging and production. This approach has become pretty common, and in most cases does a good job of balancing our desire to ship quickly with the need to control code quality.

But, what happens when a bug inevitably creeps in, and you need to determine when it was introduced? This article describes how to apply git bisect in the presence of numerous feature branches to quickly detect when things went awry in your codebase.

Enter Git Bisect

git bisect is tool for automatically finding where in your source history a bug was introduced. It saves you the pain of manually checking out each revision yourself and keeping a scratchpad for which ones were good and bad.

Here’s how you get started:

# start up git bisect with a bad and good revision
git bisect start BAD_REVISION GOOD_REVISION

At this point, git is going to start checking out each revision and asking you if the commit is good or bad. You tell git this information by typing git bisect good or git bisect bad. Git then uses binary search (bisecting the history) to quickly find the errant commit.

You can also further automate things by giving git a script to execute against each revision with git bisect run. This allows git to take over the entire debugging process, flagging revisions as good or bad based on the exit code of the script. More on this below!

Example

Imagine you go back to work from a vacation and discover that the Rails specs are running much more slowly than you remember before you left. You know that the tests were fast at revision 75369f4a4c026772242368d870872562a3b693cb, your last commit before leaving the office.

Being a master of git, you reach for git bisect. You type:

git bisect start master 75369f4a4c026772242368d870872562a3b693cb

…and then for each revision git bisect gives you, you manually run rake spec with a stopwatch. If it’s too slow, you type git bisect bad, and if it’s fast you type git bisect good.

That’s kind of monotonous, though, and didn’t we mention something about automating things with a script above? Let’s do that.

Here’s a script that returns a non-zero error code if rake spec takes longer than 90 seconds:

#!/bin/bash

start=`date +%s`
rake spec
end=`date +%s`

runtime=$((end-start))


if [ "$runtime" -gt 90 ]
then
    echo TOO SLOW
    exit 1
fi

echo FAST ENOUGH
exit 0

Let’s say you save this script to /tmp/timeit.sh. You could use that instead of your stopwatch and keep manually marking commits as good and bad, but let’s go further and have git bisect do the marking for us:

git bisect run /tmp/timeit.sh

Now we’re talking! After waiting for a bit, git tells us that the errant revision is:

31c60257c790e5ab005d51d703bf4211f43b6539 is the first bad commit
commit 31c60257c790e5ab005d51d703bf4211f43b6539
Author: John Smith john@example.com
Date: Wed Jan 21 12:02:38 2015 -0500
   removing defunct jasmine-hacks.js
:040000 040000 94ff367b586ec62bacb3438e0bc36ae62f90da22 bd3b447e7fc8ce782a7a4c01d11d97383bf06309 M karma
bisect run success

OK, so that sounds good. But wait, that’s a commit that only affected javascript unit tests! How could that have caused a problem with the Ruby specs?

Damn You, Feature Branches

The problem is that git bisect is not confining itself to only the merge commits in master. When it narrows down the point in time when things got slow, it isn’t taking into account the fact that most revisions are confined to our feature branches and should be ignored when searching the history of changes to master.

What we really want is to only test the commits that were done directly in master, such as feature branch merges, and the various one-off changes we commit directly from time to time.

git rev-list

Here’s a new strategy: using some git rev-list magic, we’ll find the commits that only exist in feature branches and preemptively instruct git bisect to skip them:

for rev in $(git rev-list 75369f4a4c026772242368d870872562a3b693cb..master --merges --first-parent); do
  git rev-list $rev^2 --not $rev^
done | xargs git bisect skip

In short, the above chunk of bash script:

  1. Gets all revisions between the known-good revision and master, filtering only those that are merges and following only the first parent commit, and then for each commit
  2. Gets the list of revisions that only exist within the merged branch, and then
  3. Feeds these branch-only revisions to git bisect skip.

Pulling It Together

Here’s the complete list of commands we’re going to run:

$ git bisect start master 75369f4a4c026772242368d870872562a3b693cb

$ for rev in $(git rev-list 75369f4a4c026772242368d870872562a3b693cb..master --merges --first-parent); do
>   git rev-list $rev^2 --not $rev^
> done | xargs git bisect skip

$ git bisect run /tmp/timeit.sh

This runs for a while, and completes with the following chunk of output:

Bisecting: 14 revisions left to test after this (roughly 4 steps)
[086e45] Merged in update_rails_4_2 (pull request #903)
running /tmp/timeit.sh
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................
Finished in 1 minute 21.79 seconds (files took 6.63 seconds to load)
719 examples, 0 failures
Randomized with seed 54869

TOO SLOW

There are only 'skip'ped commits left to test.
The first bad commit could be any of:
342f9c65434bdeead74c25a038c5364512d6b67e
9b5395a9e1c225f8460f8dbb4922f52f9f1f5f1d
dcb1063e60dbcb352e9b284ace7c83e15faa93df
027ec5e59ca4c380adbd352b6e0b629e7b407270
1587aea093dffaac2cd655b3352f8739d7d482dc
2ff4dee35fd68b744f8f2fcd5451e05cb52bff87
73773eae4f6d283c3487d0a5aea0a605e25a8d3f
1cf615c6fa69e103aea3761feaf87e52f1565335
26d43d2060880cb2dbe07932fe4d073e3ccb7d44
293190779e33e26b9ceabfcff48021507591e9d1
77d504ee4b52b0869a543670cd9eb2fb42613301
3f25514f793e87549c9d64ddcfe87f580b29f37e
d43d1845b9fd6983ff323145f8e820e3aea52ebd
32a9e3c879546d202c27e85ab847ca9325977d5c
ea3e3760fb06e3141e5d12f054c1153e55b5cc67
9665813264a5e0d7489c43db871b87e319143220
b8f5106a8901d56621e72ba6b8bd44d4d5471dd2
086e45a2c0a2ed2cd26eeb48960c60048af87d0a
We cannot bisect more!
bisect run cannot continue any more

Hooray! We’ve found our offending commit: Merged in update_rails_4_2 (pull request #903). That makes sense—we upgraded RSpec and made a bunch of testing-related changes in that branch.

Furthermore, we see a list of skipped commits that git bisect didn’t test. This also makes sense—those commits are all within the update_rails_4_2 branch.

Conclusion

With a bit of git magic and some scripting, we’ve completely automated what could have been a very tedious exercise. Furthermore, thanks to the judicious use of git rev-list and git bisect skip, we’ve been able to cajole git into giving an answer that takes our branching strategy into account. Happy hacking!

Fixturies: The speed of fixtures and the maintainability of factories

 

We had a rails app. We used factories in our tests, and it took ten minutes to run them all.  That was too slow. (spoiler alert: by the end of this blog post, they will run in one minute.)

We suspected that we could speed up the test run time by using fixtures instead, but worried that fixtures would be much more difficult to maintain than our factories.

As it happens, we are not the first developers to deal with the issue that factories are slow and fixtures are hard to maintain.  I cannot explain the issue any better than the following folks do, so I’ll just give you some quotes:

“In a large system, calling one factory may silently create many associated records, which accumulates to make the whole test suite slow …”

“Maintaining fixtures of more complex records can be tedious. I recall working on an app where there was a record with dozens of attributes. Whenever a column would be added or changed in the schema, all fixtures needed to be changed by hand. Of course I only recalled this after a few test failures.”

“Factories can be used to create database records anywhere in your test suite. This makes them pretty flexible and allows you to keep your test data local to your tests. The drawback is that it makes them almost impossible to speed up in any significant way.”

In our case, 99% of our tests were using identical records.  For example, we were calling FactoryGirl.create(:user) hundreds of times, and every time, it was creating the exact same user.  That seemed silly.  It was great to use the factory, because it ensured that the user would always be up-to-date with the current state of our code and our database, but there was no reason for us to use it over and over in one test run.

So we wrote the gem fixturies to solve the problem this way:  Each time we run tests, just once at the beginning, we execute a bunch of factories to create many records in the database.  The fixturies gem then dumps the state of the database to fixtures files, and our tests run blazingly fast using those fixtures.

We saw a 10x improvement in run times, from ten minutes down to one.  We still use factories here and there in our tests when we need a record with specific attributes or when we want to clear out a whole table and see how something behaves with a certain set of records in the database.  But in the vast majority of cases, the general records set up in that single run at the beginning are good enough.

If you are using factories in your tests to re-create the same records over and over again, and your tests are running too slowly, give fixturies a try and let us know how it goes.  It only took us about half a day to refactor 700 tests to use fixturies instead of traditional factories, so there is a good chance it will be worth your time.

text-transform: An Unlikely Source of Jank

Here at Pedago, we take a hard look at the performance of our applications so that our users don’t have to experience any troublesome hiccups (or “jank”) that might otherwise sour a sweet learning experience.

While “performance” can cover a wide array of metrics, we tend to be extremely critical of browser overhead (script execution, rendering layout, and painting). While others have covered optimization of these metrics in great detail, we came across an unlikely jank-vector that we thought was worth mentioning.

When analyzing CSS performance in relation to browser lifecycle, there are a few notorious styles (eg: border-radius, box-shadow, transform, backface-visibility, etc) that tend to slow down frame rate. Some of these are obvious as they dramatically influence the rendering process or add additional calculations for stylistic ooomph. One might be extremely likely to overlook the rather mundane text-transform while focusing on that list, though.

We had several elements each containing a finite number of additional elements that all were performing CSS-dictated uppercasing on their text content. Now, this might not be a significantly intensive operation in itself, but combined with some excessively spastic scrolling, it degraded the user experience somewhat significantly. After we updated the content to be rendered in uppercase without the need for CSS text transformation, the improvement was obvious.

Here’s how things looked on a common mobile platform, prior to the change (FPS is the key metric, with 60FPS as an ideal target):

with CSS text transform

As you can see, we were barely hitting the 30FPS threshold and often even missing that window. Here’s what we observed after we removed the relevant text-transform styles:

no CSS text transform

As you can see, we’re now closer to consistently hitting that golden 60FPS benchmark! Granted, we were probably abusing a CSS style that was intended for narrower application, and the DOM of this particular page meant that there were a lot of them, so your mileage may certainly vary. However, this might help serve others in the war against jank!

How do I read the AngularJS message: [$rootScope:infdig] 10 $digest() iterations reached. Aborting! Watchers fired in the last 5 iterations

I’ve been using Angular every day for over a year, but have always been too intimidated by this error message—and the crazy list of information that comes along with it—to really dig into it and find out how to use it to my advantage.

Building a new product at Pedago, I see this error happen from time to time in production (possibly related to a user using an old browser), but never when developing locally. So I have the error message from our error logs, but I can’t reproduce it or debug it by making changes in the code.

After researching the issue, here’s what I found out on my own.

After the colon there are two brackets. (…’atchers fired in the last 5 iterations: [[{“msg’) The first bracket is the beginning of a json block. Copy from the first bracket to the end of the error and find a way to pretty-print that json. (Use your favorite code editor or an online json formatter.)

Now you have a pretty-printed array with 5 entries in it. Each entry represents an iteration in the digest cycle, i.e. one pass through all of the active watchers in your app, looking for changes. Angular will repeat iterations until it does one in which no watcher has a changed value, or until it hits 10 iterations, at which point it will error. That’s what happened in this case.

There were 10 iterations before the error, and 5 are included in the error message. Presumably that means there are 5 more iterations that happened earlier than what is included in the error message. The first entry in the error message is the 6th iteration, and the last entry in the message is the 10th iteration.

The entry for each iteration is also an array. In this case it is an array of objects, and each object represents a watcher whose value changed during this iteration. Each object will give you the text or the function that defines the watcher, the old value for the watcher before this iteration and the new value after this iteration.

Read it from top to bottom like a story, adding commentary based on what you know about your app. In my case, I was able to see how the changes in each iteration caused new watchers to be created, requiring yet another iteration. “In the 6th iteration, this watcher changed, causing this new stuff to be rendered on the page, creating new watchers which were assigned values in the 7th iteration, and then …” There was no infinite loop or anything. In fact, if Angular had been willing to do just 1 or 2 more iterations, it would have finished.

I hope this is helpful to anyone else experiencing this issue.

Five key principles that make geographically split software teams work

Geographically distributed teams can work. How? In my experience, there are five key principles that make all the difference.

The other day, I realized that I have worked on geographically split software teams for the last decade. I didn’t set out intending to do so. When I got my first job out of college as a software engineer, I thought being in the office was non-negotiable. If you ask company recruiters, most say in no uncertain terms they are not looking for remote employees.

But the reality on the ground is that many software companies end up letting most full-time engineers work flexible hours, from anywhere. Yet few companies acknowledge or advertise this explicitly. You can’t get this opportunity by asking for it in your interview, but after you are in the door, the opportunity arises. There are a few ways this happens.

Software companies with heavy on-call burdens, like Amazon for example, end up with an unspoken but widespread assumption that people can work from anywhere because they are working all the time. Since most engineers are contractually obligated to be on-call, and emergency issues arise at all hours of the day and night, these engineers start working remotely out of necessity. Soon, whole teams realize there is no barrier to working where and when they are most productive. On any given day during my tenure at Amazon, maybe half of my teammates weren’t in the office when I was.

 I’ve worked for several startups with surprisingly similar team environments. At one, people preferred to work at nearby coffeehouses with outdoor porches that made it easier to work while smoking. At another, unreliable wireless bandwidth in the office drove people to work from home out of necessity. At another, almost every person employed there lived in a different time zone, because this startup needed a very specific set of skills that happened to be scarce at the time.

Later I went to work for Rosetta Stone, which had three offices when I started, and grew to six offices when I left . Most of the teams I worked on ended up having people in at least three office locations, and as many time zones. Only one of the four bosses I had during those years worked in the same office as me. Not only were the teams geographically split, but once a team is split across two or more time zones, for all practical purposes, this team is also working flex time hours.

 These teams all worked well together. No matter where and when we worked, everyone still was accountable for meetings and deadlines. I never felt particularly disconnected from my team, and I had rapport with and support from my bosses.

Today I work for Pedago.com, a startup company that is geographically split and has been from the very beginning. It is the most productive team I have ever worked with.

Geographically distributed teams can work. How? In my experience, there are five key principles that make all the difference.

1. Shared chat room where all team communication, questions, updates, and banter happen

I’ve used Skype, IRC, and HipChat for this — there are many viable options. In a geographically split team, showing up to the chat room is the same as showing up to work. Conversely, not showing up to chat is like not showing up to the office, with the same professional and social side effects. Knowing everyone will be in one place means you always know where you can ask questions if you have them. And if you are ever away and need to catch up on team discussion, there’s a nice transcript of all the debates, conversations, and decisions the team made while you were away that you can easily read to catch up.

2. Shared “online” hours

These are the hours everyone is guaranteed to be available in the shared chat room. No matter how scattered the team is, there will always be some set of hours that work for everyone. Everyone is assumed to be available during these hours, and if any person can’t make it or needs to leave to run errands, they are expected to notify everyone.

3. Short daily video check-in meetings

If your team uses Scrum as its project management strategy, these are just your daily standup meetings. It makes a huge difference to see peoples’ faces once a day, if only to remember that they are human beings in addition to being demanding product owners or cantankerous engineers. The visual feedback you get from face to face conversations helps facilitate complex discussions, amplifies positive feedback, and the subconscious pressure to announce a socially acceptable level of progress helps hold everyone accountable.

4. Teammates need to be aggressive about helping and asking for help.

However tempting, no one should ever spin their wheels when stuck. Teams should declare that ad hoc pair programming, calls, and hangouts are a part of their team’s working style, and developers should be aggressive about picking up the phone or screen-sharing whenever they get stuck or need to ask a question.

5. Everyone on the team needs to buy into these rules.

No exceptions. If even one person refuses to get in the shared team chat-room or doesn’t feel like showing up to the video check-in meetings every day, these strategies won’t work for the rest of the team. Everyone on the team has to buy in, and in particular, managers and team leads need to lead by example, being disciplined about leading discussions and disseminating information only in the team’s shared forums.

But how do you know people are working if you can’t see them?

Simple answer. The same way you know they’re working when you can see them: you talk to them about requirements, check in on progress, look at what they deliver. If you are a technical manager, you monitor deployments or skim the latest check-ins. Software management really isn’t very different with distributed versus in-house teams. The secret to success is still the same: clear direction, well-defined, prioritized requirements, and carefully managed execution.