David Bernstein

Member for

9 years 7 months

David Bernstein is the author of the book Beyond Legacy Code: Nine Practices to Extend the Life (and Value) of Your Software (http://BeyondLegacyCode.com). He’s trained over 8,000 professional software developers at companies around the world where his book’s advice has been successfully applied. His firm, To Be Agile (http://ToBeAgile.com), helps developers adopt Extreme Programming practices such as test-driven development, refactoring, and continuous integration.

Company

To Be Agile

Job Function

Development

Industry

Education

Interests

Agile

Design

Lean

Process Improvement

Programming

Project Management

Requirements

Security

Test Automation

Extreme Programming, TDD, CI, refactoring, emergent design

Country

United States

David Bernstein

All Articles by David Bernstein

All Stories by David Bernstein

	Cultivating Sustainable Agile DevelopmentIn agile development, we want to support a sustainable pace because we recognize that when we overwork ourselves, we tend to introduce defects that are more costly to repair than can be offset by any efficiencies we gain by putting in massive amounts of overtime. We should encourage a set of common standards and practices to help us build solutions that are more maintainable and extendable.
	Learning the Skills of a Professional Software DeveloperWe hire for programming language skills or framework experience, but these are the kinds of things that any developer should be able to pick up quickly. David Bernstein says we should be hiring based on talent instead, and mentoring developers to write code that can be maintained and extended more easily. These critical skills are best learned on the job, which is why mentoring is so valuable.
	The Agile Advantage for Last-Minute ChangesCompanies using heavyweight development processes manage change by limiting or locking down scope, but this has negative consequences for our products and our customers. Agile takes a different approach by recognizing the value of last-minute changes and making it inexpensive and straightforward to make changes to software, even late in the development cycle, using continuous integration.
	Build Just Enough of a Feature with ATDDDevelopers have a tendency to overbuild their code. This is frequently due to not knowing exactly when they're done and not knowing how robust a feature needs to be. Acceptance test-driven development (ATDD) is a great way to avoid this practice because when the acceptance test passes, the developer knows they're done building that particular feature.
	Agile Development: Focusing on the Health of Your CodeIn Scrum, the product owner and the ScrumMaster are supposed to drive sustainable development. But there's a third force missing from the formula: the health of the code itself. We often forget that our code is also a member of our team, and we have to be concerned about its health and well-being as much as any other team member. That means using practices to develop good code from the beginning.
	Software Development: An Industry of AmateursDavid Bernstein says the software industry is an industry of amateurs. It's a young field, and he doesn’t think it's yet graduated into a true profession. Here, David contrasts the software industry with other, more established fields, and he talks about what software professionals need to do in order for the industry to become accepted and esteemed.
	When Software Development Becomes a True ProfessionDavid Bernstein describes the software profession as an industry of amateurs. He argues that it does not yet have many of the things that a true profession has, such as a defined path of entry or good apprenticeship opportunities. A big reason is that computer programming hasn't been around as long as other industries, but what else will it take for software to rise in the ranks?
	Embracing the Learning Curve in Software DevelopmentIn software development, we're constantly learning new skills because we have to. Technology and its associated best practices are constantly changing, but this is a good thing—it means our industry is evolving quickly. It also means we are constantly on the learning curve. Having a good mindset about continuously learning can help you go far in the software world.
	3 Keys to Mastering Test-Driven DevelopmentFrom his decade of teaching thousands of professional software developers how to be effective with test-driven development, David Bernstein has learned that there are three key ingredients for mastering TDD: understanding what it really is, making code reliably testable, and getting hands-on experience. Let’s look at each of these factors to see what it takes to use TDD effectively on your projects.
	What's in a Name? Build Better Software by Naming Classes and Methods ClearlyOne of the most important things to pay attention to when writing software is how we name our symbols. Data and behavior should be named in a way that represents the essence of what we're trying to do. Naming affects understandability and reflects code quality, so use names that clearly communicate your intentions, and refactor those names when your intentions change.
	Why You Need to Be Doing Continuous IntegrationIt’s usually easy and inexpensive to set up a continuous integration environment for either an agile or a waterfall project. Perhaps the most obvious benefit of CI is the elimination of the integration phase that existed in traditional waterfall projects, where we typically slip the worst on deadlines. But there are many other benefits to continuous integration that you may not have considered.
	Find Your Metaphor for Agile Software DesignHow you think about software design can have a big impact on how effective you are when you do it. All of us have different criteria for success, and some of them aren’t even conscious. We have to figure out what resonates for us so that we make the right choices, and we can get a clue about the right choices for us by looking at the metaphors we use when we talk about software.
	The Value of Test-Driven Development when Writing Changeable CodeWriting changeable code makes it easier and more cost-effective to add features to existing software. Writing changeable code doesn’t take longer, but it does require paying attention to certain things when building a system. It's important to have a good suite of unit tests that support refactoring code when needed, and test-driven development helps you create independently testable code.
	Document Why as Well as What: Finding the Purpose of Your SoftwareCode can express what we want to accomplish, but it’s a little more difficult to express why we’re doing something in the first place. The people who maintain code are often not those who originally wrote it, so documenting why helps set a context and gives clues as to what the author was thinking when they came up with a particular design, making developers' jobs easier.