dimareads

The burden of maintaining mocks is by far the most common argument against mockist tests. You have to write both the implementation and at least one test double. When one changes, the other has to change too.

Perhaps most troubling, if an object's interface changes, its dependencies' unit tests will continue to pass because the mock objects will function as always — arguably a hinderance to refactoring. Since you need to test for that scenario, mockists also write integration tests. Integration tests are probably a good idea anyway, but as a mockist, you don't really have a choice.

[...]

Imagine a restaurant website that puts special emphasis on whether or not the restaurant is currently open. Instead of describing the open and close times with text, the website checks the current time and speaks to you naturally.

For example: "We're open!" or "Come quick, we're closing in an hour!" or "Sorry, we just closed. We're open until 10pm on weekdays, and midnight on weekends. Hope to see you soon!"

This is when it becomes clear that the website isn't just a PSD blindly exported to the web, as so many are. The designer clearly thought about the three most important questions that people ask a restaurant website, which are:

"Are you open?" and/or "What are your hours?"

"What's your menu?" (PS please don't link me to a PDF)

"Where are you located?"

Interesting quotes:

Meszaros uses the term Test Doubleas the generic term for any kind of pretend object used in place of a real object for testing purposes. The name comes from the notion of a Stunt Double in movies. (One of his aims was to avoid using any name that was already widely used.) Meszaros then defined four particular kinds of double:

Dummy objects are passed around but never actually used. Usually they are just used to fill parameter lists.

Fake objects actually have working implementations, but usually take some shortcut which makes them not suitable for production (anin memory databaseis a good example).

Stubs provide canned answers to calls made during the test, usually not responding at all to anything outside what's programmed in for the test. Stubs may also record information about calls, such as an email gateway stub that remembers the messages it 'sent', or maybe only how many messages it 'sent'.

Mocks are what we are talking about here: objects pre-programmed with expectations which form a specification of the calls they are expected to receive.

[...]

With classic TDD, you have to create not just the SUT but also all the collaborators that the SUT needs in response to the test. [...] Usually these objects are created and torn down with each run of the tests.

Mockist tests, however, only need to create the SUT and mocks for its immediate neighbors. This can avoid some of the involved work in building up complex fixtures (At least in theory. I've come across tales of pretty complex mock setups, but that may be due to not using the tools well.)

In practice, classic testers tend to reuse complex fixtures as much as possible. In the simplest way you do this by putting fixture setup code into the xUnit setup method. More complicated fixtures need to be used by several test classes, so in this case you create special fixture generation classes. 

[...]

If you introduce a bug to a system with mockist testing, it will usually cause only tests whose SUT contains the bug to fail. With the classic approach, however, any tests of client objects can also fail, which leads to failures where the buggy object is used as a collaborator in another object's test. As a result a failure in a highly used object causes a ripple of failing tests all across the system.

Mockist testers consider this to be a major issue; it results in a lot of debugging in order to find the root of the error and fix it. However classicists don't express this as a source of problems. Usually the culprit is relatively easy to spot by looking at which tests fail and the developers can tell that other failures are derived from the root fault. Furthermore if you are testing regularly (as you should) then you know the breakage was caused by what you last edited, so it's not difficult to find the fault.

[...]

In essence classic xunit tests are not just unit tests, but also mini-integration tests. As a result many people like the fact that client tests may catch errors that the main tests for an object may have missed, particularly probing areas where classes interact. Mockist tests lose that quality. In addition you also run the risk that expectations on mockist tests can be incorrect, resulting in unit tests that run green but mask inherent errors.

[...]

When you write a mockist test, you are testing the outbound calls of the SUT to ensure it talks properly to its suppliers. A classic test only cares about the final state - not how that state was derived. Mockist tests are thus more coupled to the implementation of a method. Changing the nature of calls to collaborators usually cause a mockist test to break.

This coupling leads to a couple of concerns. The most important one is the effect on Test Driven Development. With mockist testing, writing the test makes you think about the implementation of the behavior - indeed mockist testers see this as an advantage. Classicists, however, think that it's important to only think about what happens from the external interface and to leave all consideration of implementation until after you're done writing the test.

Coupling to the implementation also interferes with refactoring, since implementation changes are much more likely to break tests than with classic testing.

"People are more demanding for a low-cost consumer thing than they are for [expensive] profressional products," Bass told me in a sit-down at the company's slick gallery space in downtown San Francisco. "The cheapest things have to be the easiest to use," he explained. They don't get a user manual or training classes to show people how to use them.

(...)

Conclusions first, explanations later

Using $(expr) to do math is over a hundred times slower than using bash internals. This is not a new discovery, but it’s worth reiterating. (...)

$(expr) is commonly recommended for implementing counters in shell scripts, but this is bad advice.

Excessive use of sub processes (see point 1) can confuse the Linux kernel’s power management algorithms, leading to an additional three times slowdown. Interesting… (...)

We can see that the overall task is CPU bound. The bash process runs for a fraction of a millisecond, then exprlaunches, then expr moves to another core, then expr terminates and the cycle repeats.

After discussions with some kernel developers it appears that new processes are placed on the least-busy core, however that doesn’t explain why bash keeps moving or why each expr instance moves once.

The net result is that none of the CPUs are fully loaded which, apparently, means that the power management algorithms don’t realize that a CPU bound task is running. It’s kind of crazy awesome, and it is an example of when a multi-core system actually runs (a lot) more slowly than a single-core system. 

  time gives accurate elapsed time information but its CPU time information should not be trusted, especially if you make excessive use of sub processes (see point 1). (...)

So, be aware that time always underestimates CPU time, and that this underestimation is roughly proportional to how many sub processes you create per second. Presumably the process creation time is being attributed neither to the parent nor the child process, even though it really should be, as sys time.

(...) I assume that the problem is ultimately a limitation of what the Linux kernel reports back to time, so the proper fix here is probably to acknowledge the limitation in the man page. 

To be crystal clear, my complaint/concern is that (...) it makes the loop seem like it is not CPU bound, when it is. This can lead a performance investigation astray. I believe that this should be fixed, or documented.

When time lies you can always use the Windows Task Manager to measure Linux CPU consumption. Amusing.  

Looping in Windows batch files can be faster than looping in Linux shell scripts.  

Several car companies have recently created smartphone apps that allow drivers to unlock their car doors. Generally, the unlocking feature plays out like this:

A driver approaches her car.

Takes her smartphone out of her purse.

Turns her phone on.

Slides to unlock her phone.

Enters her passcode into her phone.

Swipes through a sea of icons, trying to find the app.

Taps the desired app icon.

Waits for the app to load.

Looks at the app, and tries figure out (or remember) how it works.

Makes a best guess about which menu item to hit to unlock doors and taps that item.

Taps a button to unlock the doors.

The car doors unlock.

She opens her car door.

Thirteen steps later, she can enter her car.

The app forces the driver to use her phone. She has to learn a new interface. And the experience is designed around the flow of the computer, not the flow of a person.

If we eliminate the UI, we’re left with only three, natural steps:

A driver approaches her car.

The car doors unlock.

She opens her car door.

Anything beyond these three steps should be frowned upon.

Seem crazy? Well, this was solved by Mercedes-Benz in 1999. 

(Source: YouTube)

[...]

Alternatively, No UI systems focus on you. These systems aren’t bound by the constraints of screens, but instead are able to organically and rapidly grow to fit your needs.

For example, let’s talk about Trunk Club.

It’s a fashion startup.

They think of themselves as a service, not a software company or an app-maker. That’s an important mind set which is lost on many startups today. It means they serve people, not screens.

And I guess if we’re going to talk about Trunk Club, I’ve got to mention a few of their peers: Bombfell,Unscruff, Swag of the Month and ManPacks.

After you sign up for Trunk Club, you have an introductory conversation with a stylist. Then, they send your first trunk of clothes. What you like, you keep. What you don’t like, you send back. Based on your returns and what you keep, Trunk Club learns more and more about you, giving you better and better results each time.

Diminishing rate of return over time? Nay, increasing returns.

Without a bulky UI, it’s easier to become more and more relevant. For fashion, the best interface is no interface.

Another company focused on adapting to your needs is Nest.

When I first saw Nest, I thought they had just slapped an interface on a thermometer and called it “innovation.”

[...] regressions were a constant issue for LibreOffice. To deal with them, the project has taken several approaches to ramp up code quality without killing progress in the name of stability. They've greatly increased the number of unit tests available, which has allowed more changes to be made more quickly, adapting to the ever increasing flow of contributions from new contributors.

[...]

All the same, breakage happens, but a brilliantly simple invention by team member Bjoern Michaelsen of Canonical has allowed anyone on the QA team to locate the bugs that cause regressions. Git includes the git bisect command, which helps pinpoint regressions. The developer identifies a version of the code with the defect under investigation, as well as a historic version that did not exhibit the defect. Git then offers a commit between those two and asks if that version exhibits the defect. By repeatedly bisecting the list of commits, Git permits rapid isolation of the point the defect was introduced.

A new enhancement for Git Standard enough, but LibreOffice is a huge, complex code base, with often 50 or more commits per day. Building any one of them could take several hours, rendering the bisect process infeasible.

Interesting point made by Dan Pallotta  about the connection between your loyalty to yourself, and your honesty about your product.

Your ability to stand up for your truth is a muscle, and the more you exercise it the stronger it gets. [...]

People at all levels, especially management, witness the slow undoing of good customer service, product quality, or safety standards, and they don't say a thing about it. Even if it violates their own value system and the mission of the company. But if everyone at a crummy airline, for example, had the same zero-tolerance for bad customer service as a lesbian has for lying about the fact that she's married to a woman, it wouldn't be a crummy airline for long. To stand up for your truth is to be a leader.

Zeroing out a CPU register seems like the simplest and most basic operation imaginable, but in fact x86 CPUs contain a surprising amount of special logic to make this operation run smoothly. The most obvious way of zeroing an x86 CPU register turns out to not be the best, and the alternative has some surprising characteristics.

[...]

The recommended alternative for years has been to use xor eax, eax. Any register exclusive ored with itself gives zero, and this instruction is just two bytes long:

33 C0                xor         eax, eax

If you really understand how CPUs work then you should be concerned with possible problems with using xor eax, eax to zero the eax register. One of the main limitations on CPU performance is data dependencies. 

[...]

It turns out that for many years x86 processors have for years handled xor of a register with itself specially. 

[...]

One of the things that stood out to me in watching the video was how much my mind seems to work like a computer.

[...]

In programming language terms, I seem to be doing some kind of just-in-time compilation. The first time through, I read and interpret every instruction. Afterwards, it seems like I remember what this function does and am able to determine its output much quicker.

[...]

continuing the topic of product pivoting and listening to your users from Three Lessons on Pivoting Your Product

Everybody thought of Excel as a financial modeling application. It was used for creating calculation models with formulas and stuff. You would put in your assumptions and then calculate things like “if interest rates go up by 0.00001% next year, what percentage of Las Vegas homeowners will plunge into bankruptcy?” For example.

Round about 1993 a couple of us went on customer visits to see how people were using Excel.

[...]

Over the next two weeks we visited dozens of Excel customers, and did not see anyone using Excel to actually perform what you would call “calculations.” Almost all of them were using Excel because it was a convenient way to create a table.

[...]

What was I talking about? Oh yeah... most people just used Excel to make lists. Suddenly we understood why Lotus Improv, which was this fancy futuristic spreadsheet that was going to make Excel obsolete, had failed completely: because it was great at calculations, but terrible at creating tables, and everyone was using Excel for tables, not calculations.

Bing! A light went off in my head.

The great horizontal killer applications are actually just fancy data structures.

Spreadsheets are not just tools for doing “what-if” analysis. They provide a specific data structure: a table. Most Excel users never enter a formula. They use Excel when they need a table. The gridlines are the most important feature of Excel, not recalc.

Word processors are not just tools for writing books, reports, and letters. They provide a specific data structure: lines of text which automatically wrap and split into pages.

First, it’s about admitting when your good software isn’t great by looking at real engagement numbers and then pivoting the product. Their first product by most measures was a wild success, but engagement numbers showed that over time people dropped off their usage. (this is common with To-do apps) Most startups can’t or won’t admit something like this or would at least cling to the notion that their software was just missing some feature or other and they would still be iterating on it. Bravo to Orchestra for pivoting in a tough place.

This is really important for actual live programs.

Learning from your users is critical to long-term success, and learning what problems they are trying to solve, or why are they leaving, is a great way to avoid feature creep.

Yet another proof that smart creative people are smart and ... well, creative:

[...] by testing the “prototypes” your competitors have already built, you can learn a ton about users’ reactions to different designs, business models, and messaging. Free!

[...]

The goal is to learn which parts of each product are more and less successful — not to pick a winner. 

[...]

Distributed Management - Ryan Tomayko of Github

This is certainly how I envision large project groups working, and a much healthier process than the rigid structural teams, groups, divisions and departments that you  see in the older dinosaur companies.

The current rigidity is a product of how industrial factories used to work. But what people forget about factories, that factories were based on large groups of low-skilled laborers and you had to have someone to manage them on issues they did not understand. These conditions don't exist in modern information-rich workplaces. Yes, not everyone are able to self-manage, and yes not everyone are good communicators. But that's why the company would hire differently talented people and let them naturally fill the required roles. This would let talent, qualification and experience as they are empirically proven in work, fill the place of a couple of work interviews setting up a pre-defined path for your career.