Welcome changing requirements, even late in development. Agile processes harness change for the customer’s competitive advantage.
The second agile principle can be expressed in two words: embrace change. It is an appeal in opposition to the traditional fixed cost waterfall model. The waterfall model makes change as hard as possible. Every time a requirement changes, the waterfall model prescribes that specifications are rewritten, the estimate is updated and the contract renegotiated. As this involves considerable administrative effort, there is a high barrier to change. This barrier is intentional, because change is considered detrimental. The waterfall model attempts to eliminate uncertainties and perceives change a risk to project success.
However, if you have worked in project management for any length of time, you will know that change is inevitable. Organisations and businesses are not static. They grow and evolve. Their external environment puts them under constant pressure. Markets, competitors, changing regulations, and new technologies force organisations to respond and adapt. Likewise, internal changes happen all the time. When an organisation expands or takes on new projects, for example, internal structures and procedures often require overhaul. This in turn means that software requirements change. Because the degree to which organisations are computerised is increasing, the rate of software requirements change is also increasing. Consequently, we can expect that change is a constant and that the pace of change accelerates.
This is were the second agile principle comes in. The agile philosophy accepts change and uncertainty as “facts of life” so to speak instead of creating an artificial bulwark against it. The very meaning of agility is defined by this principle and this is a major departure from traditional project management. It is important to understand the implications of embracing change. What does this mean for the software development lifecycle and how does it affect the planning process? One can’t deny that welcoming change implies welcoming uncertainty, because change is hardly ever predictable. The farther one tries to look into the future, the less predictable it becomes. But how do you welcome uncertainty in project planning? The agile answer to this question is temporal focus.
In agile frameworks such as Kanban and Scrum, project goals are well defined only for the present and for the immediate future. For example, Kanban is like a pipeline where the focal point is narrowed on the tasks that are currently flowing through it. These tasks are described in detail, whereas the tasks that are queued receive less attention. Scrum is an iterative framework where the focus is on the current iteration (Sprint), whereas the backlog is out of focus. This means that tasks in the intermediate future are less defined. The degree of detail is limited and the time and effort estimations are rough. Tasks in the farther future are even more fuzzy. There may be large scale goals, roadmaps and ballpark estimates, but these are open to change. So, an important difference to the waterfall model is that projects are not determined from beginning to the end.
The fuzziness of long-term and indefinite future projects is not necessarily a disadvantage. It is the price of agility, so to speak. It affords nimbleness and the ability to harness change, which brings us back to the phrasing of the second agile principle. What exactly does it mean to “harness” change? Wasn’t change something that traditional project management tries to avoid? At the basic level, harnessing change means not being overwhelmed or overrun by external events. This is something that happened all too often in the past. Because agile methods are lightweight by definition, the agile team can respond and adapt to external changes quicker and more gracefully, even if such changes entail undesirable aspects.
At a more advanced level, change is proactive and initiated by the project team. For example, the project team might decide to adopt a new technology, or it may decide to include new features, or it may respond to a specific competitive challenge. The possibilities are endless. Because the cost of rethinking and overturning things is low in comparison with traditional project management, agile methods excel in responsiveness. This is especially relevant in environments that develop at a fast pace, such as emerging markets and technologies. Which brings us to the last term of the second principle: the customer’s competitive advantage. A competitive advantage is created when an organisation gets ahead of its competitors. Being the first to release a new feature or a new technology, for example, creates a competitive advantage. Agile project management is uniquely suited to such achievements.
Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
year has 12 months and agile development is based on 12 principles.
Today, let’s start with the first agile principle. It is about
customer orientation, perhaps the main motivation for agile
development. Some of you might know, that it is now 18 years ago
since a group of software engineers came together in Snowbird, Utah
for a brief winter conference on project management. The result of
that meeting was the well-known Agile Manifesto. It had a big and
lasting impact on the software industry. Somewhat later the Agile
movement started out and today, agile methods can be considered
mainstream. However, back then things were different.
university and during the early years of my career I learned that
software development is divided into six stages. It starts with
requirements analysis followed by three production phases, followed
by deployment and maintenance. It was understood that the software
development lifecycle (SDLC) phases are strictly linear and
sequential. One is completed after the other. The customer is only
involved in the first and the two last of these phases. Software
companies spent enormous efforts on analysis, planning and
documentation in order to get cost and time estimates right.
Customers had to be enormously patient to wait for functioning
software and they had no say in its production.
process carried significant risks and turned out to be frustrating
for both parties. Although customers initially received detailed
contract specifications and a fixed price offer, the product was
regularly late and below expectations. Even worse, some requirements
changed during implementation and thus the software was already
outdated at the time of delivery. Another costly change order was
then inevitable. Things weren’t much better for developers.
Unforeseen events and technical difficulties led to exceedance of
cost and time estimates. In the worst case scenario, these
circumstances left the developer unable to fulfill the contract and
pushing towards bankruptcy. The client received either no product, or
an unusable product for their investment.
2001, I was managing my second startup company and had no intention
of repeating past mistakes in project management. Like many others at
the time, I used a homegrown set of lightweight methods for SDLC
management. I had acquired these during the late nineties in my
practical work with different clients. I knew nothing about the Agile
Manifesto at the time, but I found that the traditional waterfall
approach didn’t work for us. Instead, I visited my clients every
two weeks. During a long meeting which often took the larger part of
a day, I would first present the new features that my team and I had
developed. I would then install the update on my clients’ servers
(this was well before the time of Internet-based deployments).
Finally, I would discuss the most-wanted features and changes for the
next cycle. There was an understanding that if the client found any
bugs, they would be fixed immediately within a single release cycle.
this work so well? Because the customer was always kept in the loop.
They received usable software every two weeks that provided actual
business value. They could control and even participate in the design
process. They could correct mistakes early. Last but not least, their
financial commitment wasn’t burdened by huge risk, because they
paid monthly installments. This way of working puts the client in
control and keeps them happy. And this is exactly what the first
agile principle is about. I learned about agile project management
only some years later and I found it to be an excellent fit for what
we were doing. It confirmed our practice as a development company and
it also broadened and enhanced our methods.
reason why the this principle is the first, is given in the beginning
clause: our highest priority is to satisfy the customer.
Fundamentally, the agile methodology is about customer satisfaction.
Normally, the customer is thought of as a third party outside the
software company, but it could very well be the same company doing
in-house development. It doesn’t matter. In the latter case, the
customer role is filled by another department within the
organisation. It is important to note that neither technical goals,
nor abstract principles of management provide the foundation for
agile development, but business goals. The middle part of the
sentence mentions early and continuous delivery. This makes perfect
sense from the perspective of developers, because software artefacts
evolve and grow in small incremental steps. It also makes sense from
the perspective of the customer, because they can begin using
individual features before the entire package is completed.
more benefits are reaped by early and continuous delivery. The
customer can control and prioritise the development of individual
components. Mistakes can be corrected cost-efficiently at an early
stage. The customer can verify or invalidate concepts in practical
application. Developers are able to create proof-of-concepts without
committing to a specific design or technology too early. Finally, the
first agile principle speaks of the delivery of valuable software.
The value of software is what clients and developers ultimately aim
to realise together. This always translates into some sort of
business value. For example, the software might enable the client to
respond faster to their own clients. Or it may automate some task
which previously had to be done in a tedious manual way. Or it may
enable the client to gain deeper insights into markets,
opportunities, and risks. The possibilities are endless. The sooner
the software enters production stage, the earlier the customer can
reap its benefits.
summary, the first principle encapsulates the motivation and mission
for agile development. It’s all about customer satisfaction and
providing business value through software.
As a developer, you probably have gone through one or more coding interviews. When applying for a developer job, you are expected to demonstrate some level of programming chops by solving algorithmic problems on a whiteboard or in an online code editor. This practice is not new. My first coding interview took place more than 25 years ago sitting at a lovely green text terminal. However, it has recently proliferated and became an integral and often time-consuming part of the interview process. Especially big American tech companies like Amazon, Apple, Facebook, Google and Microsoft are pushing the envelope. To land a developer job at one of these companies, you are now expected to be able to recite the finer points of an algorithm manual and produce solutions with O log(n) time complexity in a trice.
Does that sound just slightly ridiculous to you? Perhaps it is. The question one must ask is whether having candidates produce algorithms is actually a good indicator for success in the software development profession. I have been sitting at both ends of the interviewer’s table many times, and I am quite ready to doubt this implication. There isn’t much empirical evidence to support the thesis that people who score high on coding interviews also do well in their jobs. Actually, there is none. Even Google’s own study concluded that interview scores don’t correlate with job performance. Gayle Laakmann Mc Dowell, the author of the book “Cracking the Coding Interview” says: “No one really knows, but it’s very reasonable to assume that there is a link,” and “Absence of evidence isn’t evidence of absence.”
Sorry, that’s not good enough for me. Let’s be a little more scientific.
Perhaps we begin by determining what is actually measured by solving an algorithmic problem. The coding interview is akin to a school exam. It measures how good you are at applying textbook solutions to a given task. Just as in an exam situation, you can improve your score by studying hard. The domain is broad enough to provide sufficient variation in different fields from number theory and graph theory to combinatorics and set theory. Yet, algorithms themselves are very narrow as they deal with a specific solution to a specific problem. A successful coding interview demonstrates three things: 1. the candidate can write code, 2. the candidate has a grasp of algorithms and can memorize textbook solutions, 3. the candidate can reproduce and explain these solutions.
At first glance, this seems useful. These traits are surely expedient in typical development work. They’re kind of expected from developers. But does the coding interview also measure how well pronounced these traits in a particular applicant are? Can standardised interviews establish a framework for comparison? The answer is sadly no. One applicant might receive a familiar problem that he can solve and pass with flying colours. Another more talented applicant might have never before encountered the same problem and fails to solve it. A third applicant may get bogged down by anxiety. Yet another applicant may solve the problem, but produces bugs because of using an unfamiliar language. The result is influenced by many factors and it is notoriously unreliable.
This is not the only problem. There is a more serious one: the coding interview only probes a very narrow set of skills. Being able to produce algorithms is not sufficient to become a successful developer. For example, a developer also has to read and interpret requirements, communicate within a team and with business people, have knowledge of technologies and best practices, perhaps also have an understanding of certain industries. In this light, being able to memorise textbook algorithms seems somewhat less relevant. After all, you can always look up a manual when in need of an optimised algorithm for a specific problem. This is probably what most developers would do in their day-to-day work.
I remember a peculiar coding interview that took place 10 years ago on the phone before shared online code editors became a thing. I was asked to spell out an algorithm that produces the series of prime numbers. “No problem,” I said, “just let me google the sieve of Eratosthenes.” “No no, let’s just improvise,” said the interviewer, “it doesn’t have to be perfect.” So I scribbled down some similar, yet doubtlessly inferior code that mimicked Eratosthenes’ idea and read it out loud (awkwardly) on the phone. Something I would never do in an actual work situation. Yet, I passed the interview and got the assignment.
Is this a good predictor of professional performance? No, it isn’t. It is way too arbitrary and readily produces false negatives as well as false positives. There is a considerable amount of HR management literature that has identified good and bad predictors for work performance. Among the worst predictors are first impressions, school grades, and brain teaser questions, such as “how many golf balls can you fit into a phone booth?” Finding the answer to that is a lot like devising an algorithm for a geometry problem. You get the clue. Case in point: Max Howell, the author of the popular “Homebrew” package manager for macOS was (infamously) rejected in a Google interview, because he was not able to produce an algorithm for inverting a binary tree. Howell’s software is used by millions of Mac users and is now maintained by a team of 21 people. Yet, he wasn’t good enough for Google.
One of the best predictors for future job performance is past performance. Duh. It’s kind of obvious and also backed up by evidence in the form of empirical studies in management. Had Google considered past performance instead of algorithms, the company would now be richer by one accomplished engineer, who according to his own words cares more about user experience than about computer science. People often have special talents that evade the standardised interview process. They will not escape an experienced interviewer, however. The only problem with past performance is that data is not always available. For example, what about grad students, career changers, and people with little work experience? Well, the second most reliable predictor for job performance is cognitive ability, also known as “g factor” or general intelligence. The literature is again quite solid on this point.
It stands to reason that a standardised and culturally neutral IQ test provides a much better predictor for future performance. And by “much better” I mean an order of magnitude better. It is also less time-consuming than going through a series of algorithm/coding problems. So why are companies not using them? One reason is that in certain countries, such as the USA, IQ tests are seen as potentially discriminatory and could therefore be legally contestable. This is obviously a matter of policy, and well idiocy. Encountering an IQ test in a job interview appears to raise more eyebrows than encountering a esoteric programming problems. Another reason is that high quality standardised and culturally neutral IQ tests are somewhat difficult to develop. And new ones would have to be developed all the time to ensure high quality results and to prevent abuse. Yet another predictor for career success was recently (2013) suggested by Angela Lee Duckworth in a TED talk. She called it “grit”, or the “power of passion and perseverance” and subsequently received a lot of attention from the tech industry. The problem with “grit” is that as of now no reliable way of measuring it has been devised.
So, the question that springs to mind is: why do companies use coding interviews in the selection process if they already know that the resulting score is a poor predictor for career success. Frankly, I don’t know. If you’re a big tech HR manager, please comment and enlighten us. I can only speculate. Companies like Facebook, Google or Apple are swamped with applications and might have to create artificial barriers to filter applications and reduce the number of candidates to a manageable amount for round two. What does this artificial barrier achieve? Perhaps it is about grit. Only the ambitious candidates will pass, namely the ones that are willing to learn and memorise algorithm textbooks just for the interview, and just for getting the chance to land a job with that big tech company. It is reasonable to assume that someone who has the motivation to put in three or four weeks of cramming for an interview, is also motivated to put in hard work into their job. In this case, developer interviews could just as well require candidates to conjugate Latin declinations and cite Roman philosophers. The effect would be the same, although it would certainly raise many eyebrows.
Another plausible explanation is that companies nowadays tend to put processes over people. The decision making process, especially in large enterprises, is highly formalised. Instead of leaving the hiring decision to an experienced HR manager who relies on their personal knowledge and skills, it is relegated to an impersonal procedure that produces data. On one hand, this frees decision makers from personal accountability. On the other hand it provides an instrument that top management can manipulate at will. For example, if management should want to steer their engineering staff into a new direction, it could replace algorithm questions with machine learning questions. Whatever the reasons may be, we can be sure that thousands of smaller tech companies will follow suit and imitate the example of Google, Microsoft and others, even if they don’t understand their reasons and even if the adopted procedures aren’t fitting their own true needs.
In the end, I believe coding interviews are not totally useless. They are an effective means to engage the candidate in his field and simulate a work situation. The coding interview gives the interviewer a chance to observe how a candidate approaches technical problems. For example, it may reveal whether the candidate’s course of action is methodical, or whether they have exaggerated their familiarity with a certain technology. Under ideal circumstances, it can reveal a lot about how a developer thinks. However, since an interview is a special situation these indicators need to be evaluated carefully. For the benefit of all involved parties, the coding interview is best conducted in a casual way. An expanded problem space leaves the candidate with more choices and is is likely to provide more information. I don’t see any good reason, why coding interviews should be conducted like a university exam, however. If you can think of any, please let us know.
I recently installed Arch Linux on a new Dell Laptop with hybrid GPUs and UEFI. The firmware did not allow switching to legacy MBR boot mode, which I normally prefer because it is easier to install, so I had no choice in this case. To aggravate things, the newly created UEFI partition wasn’t recognised by the firmware and the computer didn’t boot. If you are in a similar situation, the following instructions might help.
I assume that you have created an UEFI partition of at least 300 MB using type “EFI SYSTEM” and GUID partition table on /dev/sdb1. Your actual device may differ, for example it could be /dev/sda1 or /dev/sda2. I also assume that you have mounted the the UEFI partition as follows:
# mkdir /boot/efi
# mount /dev/sdb1 /boot/efi
Furthermore, I assume that you have installed Grub successfully with:
Normally this should leave you with a bootable system. In my case, however, I had old “ghost” bootloader entries left which were invalidated by recreating the UEFI partition. I first had to manually remove these. For this purpose, I used efibootmgr. Invoking the command without parameters shows a list of boot loader entries. For example:
Timeout: 0 seconds
Boot0003* Diskette Drive
Boot0004* USB Storage Device
Boot0005* CD/DVD/CD-RW Drive
Boot0006* Onboard NIC
Boot0007* UEFI: SK hynix SC311 SATA 256GB, Partition 1
Let’s assume that 0002 is an invalid entry. You can delete it with:
# efibootmgr -b 2 -B
Not that 2 is written without preceding zeros. You can also change the boot order or activate and deactivate single boot loaders with the same command. If this should not work, it can also be done using the firmware user interface in most cases.
Before I got my system to boot from my SSD, I executed two more steps to help the computer locating the Grub bootloader. First, I copied the bootloader itself to an alternative location. Keep in mind that /boot/efi still refers to the mounted UEFI partition (/dev/sdb1 in my case).
A few weeks ago I upgraded my Ubuntu from 16.04 to 18.04.1. I wanted to do the upgrade earlier, but reports of compatibility issues kept me waiting for the first maintenance release. The upgrade went trouble-free as expected. I think Canonical did a great job on the installer and the Gnome customisations. However, as with previous Ubuntu upgrades, there were quite a few post-installation issues.
The problem I noticed first was that the update had somehow jumbled the hotkey mapping. OK, no problem to fix that manually. Next, I couldn’t connect to the MySQL server any longer as the update had replaced the config file. This was also not a big deal, because the update process saves all existing configs. I simply had to restore the relevant lines. A bit trickier was the PHP installation. It seems that the old 7.0 package was left intact and the 7.2 version was installed only partly by the upgrade. I am not able to add modules to the 7.0 package any longer, since the PPA repositories changed.
I also encountered a few UI problems with scrolling and text pasting. For a week, I could not scroll terminal output back until I found a fix for this problem. Copying and pasting text is very slow sometimes. Could have to do with the switch from Unity to the Gnome shell. I wasn’t able to figure it out yet. All in all, a fresh installation would have been cleaner and less troublesome. However, I don’t want to go through that, as it would force me to reinstall all applications and reconfigure my Docker-based development setup, which surely takes more than a day.
With Ubuntu, or Debian, or in fact any other non-rolling Linux distro, major updates are released at least once a year. Even with LTS releases, you have to update every two years. Most packages are quite outdated at that time. In software development, we are striving to shorten release cycles ideally to a continuous deployment model. Therefore, it becomes more important to keep libraries and tools up-to-date. Simultaneously, deployments and tool chains are increasing in complexity. Hence, reinstalling environments from scratch becomes more cumbersome.
For these reasons, I decided to migrate to a rolling Linux distribution. Ubuntu is great and I really like the ease of installation and the fact that it is stable and well supported. But perhaps it’s time to try out something new. The obvious choice for me would be Arch Linux, so I installed Arch and a few of its derivates in virtual machines to get a feel for it. I am going to pick one of them and maintain the Vbox for a while before installing it on bare metal. As of now, I am not sure whether Arch is stable enough to function as a primary environment for daily work.
The Arch Linux base distro is certainly special. Its installation process is entirely manual and the resulting image is quite Spartan. You have to bootstrap everything by hand and even for someone experienced it takes a few hours until everything, including a graphical desktop environment, is configured and running. The advantage is that the system is completely customisable and can be configured exactly to your needs. Kind of nice.
I’ve also tried Manjaro and Antergos, both Arch-based distributions. They are significantly easier to install and also provide more convenience for configuration. For example, Manjaro has a nice graphical tool for managing kernel versions and Antergos offers six or seven different desktop environments out of the box. Like Arch, they are based on the Pacman installer. Although there are only about 11,000 packages in the Arch repository, the AUR (Arch User Repository) adds another 47,000 packages which is on par with the biggest Linux distributions.