|
Showing 1 - 2 of
2 matches in All Departments
It takes a week to travel the 8,000 miles overland from Java to
Kotlin. If you're an experienced Java developer who has tried the
Kotlin language, you were probably productive in about the same
time. You'll have found that they do things differently in Kotlin,
though. Nullability is important, collections are different, and
classes are final by default. Kotlin is more functional, but what
does that mean, and how should it change the way that you program?
And what about all that Java code that you still have to support?
Your tour guides Duncan and Nat first made the trip in 2015, and
they've since helped many teams and individuals follow in their
footsteps. Travel with them as they break the route down into legs
like Optional to Nullable, Beans to Values, and Open to Sealed
Classes. Each explains a key concept and then shows how to refactor
production Java to idiomatic Kotlin, gradually and safely, while
maintaining interoperability. The resulting code is simpler, more
expressive, and easier to change. By the end of the journey, you'll
be confident in refactoring Java to Kotlin, writing Kotlin from
scratch, and managing a mixed language codebase as it evolves over
time.
Foreword by Kent Beck ""The authors of this book have led a
revolution in the craft of programming by controlling the
environment in which software grows." "--Ward Cunningham" """At
last, a book suffused with code that exposes the deep symbiosis
between TDD and OOD. This one's a keeper." "--Robert C. Martin ""If
you want to be an expert in the state of the art in TDD, you need
to understand the ideas in this book."--"Michael Feathers
Test-Driven Development (TDD) is now an established technique for
delivering better software faster. TDD is based on a simple idea:
Write tests for your code before you write the code itself.
However, this "simple" idea takes skill and judgment to do well.
Now there's a practical guide to TDD that takes you beyond the
basic concepts. Drawing on a decade of experience building
real-world systems, two TDD pioneers show how to let tests guide
your development and "grow" software that is coherent, reliable,
and maintainable. Steve Freeman and Nat Pryce describe the
processes they use, the design principles they strive to achieve,
and some of the tools that help them get the job done. Through an
extended worked example, you'll learn how TDD works at multiple
levels, using tests to drive the features and the object-oriented
structure of the code, and using Mock Objects to discover and then
describe relationships between objects. Along the way, the book
systematically addresses challenges that development teams
encounter with TDD--from integrating TDD into your processes to
testing your most difficult features. Coverage includes -
Implementing TDD effectively: getting started, and maintaining your
momentum throughout the project- Creating cleaner, more expressive,
more sustainable code- Using tests to stay relentlessly focused on
sustaining quality - Understanding how TDD, Mock Objects, and
Object-Oriented Design come together in the context of a real
software development project- Using Mock Objects to guide
object-oriented designs- Succeeding where TDD is difficult:
managing complex test data, and testing persistence and concurrency
|
You may like...
Morbius
Jared Leto, Matt Smith, …
DVD
R179
Discovery Miles 1 790
|