Pragmatic Unit Testing in Java 8 with JUnit »

The Pragmatic Programmers classic is back! Freshly updated for modern software development, you'll learn mnemonics to help you know what tests to write, how to remember all the boundary conditions, and what the qualities of a good test are. You'll see how unit tests can pay off and how to handle the stuff that seems too tough to test.

Seven More Languages in Seven Weeks »

New programming languages arm you with the tools and idioms you need to refine your craft. Each language included here will take you on a step-by-step journey through the most important paradigms of our time. You'll learn seven exciting languages: Lua, Factor, Elixir, Elm, Julia, MiniKanren, and Idris. Now in print.

Recently Released:

• Dart 1 for Everyone 
• Fire in the Valley 
• Learn to Program with Minecraft Plugins (2nd edition) 
• Programming Google Glass (2nd edition) 

Great programmers aren't born—they're made. And we're here to help.

Back in October 2003, Andy and Dave started the Pragmatic Bookshelf with the first, most basic and most important topics: version control and unit testing. Now Jeff Langr brings unit testing into the modern age with the updated Pragmatic Unit Testing in Java 8 With JUnit, now in beta at pragprog.com/book/utj2. Get a set for your whole team, and get back on board with this fundamental technique.

The industry is moving from object-oriented languages to functional languages, and you need to commit to radical improvement so that this trend doesn't pass you by. Seven More Languages in Seven Weeks is now in print and shipping from pragprog.com/book/7lang. You know you want a copy under your tree.

Come and get 'em!

Pragmatic Unit Testing in Java 8 with JUnit

Pragmatic Unit Testing in Java 8 With JUnit steps you through all the important unit testing topics. If you've never written a unit test, you'll see screen shots from Eclipse, IntelliJ IDEA, and NetBeans that will help you get past the hard part—getting set up and started.

Once past the basics, you'll learn why you want to write unit tests and how to effectively use JUnit. But the meaty part of the book is its collected unit testing wisdom from people who've been there, done that on production systems for at least 15 years: veteran author and developer Jeff Langr, building on the wisdom of Pragmatic Programmers Andy Hunt and Dave Thomas. You'll learn:

• How to craft your unit tests to minimize your effort in maintaining them.
• How to use unit tests to help keep your system clean.
• How to test the tough stuff.
• Memorable mnemonics to help you remember what's important when writing unit tests.
• How to help your team reap and sustain the benefits of unit testing.

You won't just learn about unit testing in theory—you'll work through numerous code examples. When it comes to programming, hands-on is the only way to learn!

Now in beta from pragprog.com/book/utj2.

Seven More Languages in Seven Weeks: Languages That Are Shaping the Future

Learn from the award-winning programming series that inspired the Elixir language. Hear how other programmers across broadly different communities solve problems important enough to compel language development. Expand your perspective, and learn to solve multicore and distribution problems.

In each language, you'll solve a non-trivial problem, using the techniques that make that language special. Write a fully functional game in Elm, without a single callback, that compiles to JavaScript so you can deploy it in any browser. Write a logic program in Clojure using a programming model, MiniKanren, that is as powerful as Prolog but much better at interacting with the outside world. Build a distributed program in Elixir with Lisp-style macros, rich Ruby-like syntax, and the richness of the Erlang virtual machine. Build your own object layer in Lua, a statistical program in Julia, a proof in code with Idris, and a quiz game in Factor.

When you're done, you'll have written programs in five different programming paradigms that were written on three different continents. You'll have explored four languages on the leading edge, invented in the past five years, and three more radically different languages, each with something significant to teach you.

Seven Lessons from Seven More Languages in Seven Weeks

With each passing day, it is becoming more likely that new programmers will use functional programming, an entirely new programming paradigm. Each of the new languages has something unique to teach the next generation of programmers.

1. To learn functional programming, learn functional composition first. Programmers who want to improve themselves are learning functional programming in increasing numbers. Factor is a great language for learning about the composition of functions. The concatenative language forces new users to think through how functions will work together.
   
2. If you want to learn JavaScript, learn how prototypes work first in a simpler language.
   New JavaScript programmers are often better off learning a language like Lua first, which has the same overall model but fewer distracting concepts than JavaScript.
   
3. You don't need callbacks to build a beautiful user interface. Reactive programming is a new style of user interface development that helps build highly interactive and reliable applications. The Elm programming language is a language with reactive concepts baked in, from the inside out, and it compiles to JavaScript.
4. To build better cloud applications, your applications need to know how to fail. Applications are becoming more distributed than ever before. Elixir is among the most promising young languages for building cloud applications that scale well and handle failure in a sensible, reliable way. Elixir combines the natural syntax of Ruby with Clojure-style macros, all on the Erlang virtual machine for distribution and failover.
   
5. Technical computing will hit the limitations of multicore architectures before most other programming branches will. Scientific computing is increasingly hitting a wall because existing languages don't take full advantage of multicore architecture. The Julia language is growing quickly, allowing familiar programming approaches but enabling much more scalable and powerful mathematical models without dropping into C++.
6. Use logic programming when you need to build applications that "think." You don't need to know Mercury or Prolog to write logic programs. If you find yourself needing to occasionally solve logic problems, use a library instead. MiniKanren is one such library that is available in languages like Haskell and Clojure.
7. You don't need to use Haskell, Agda or Idris to take advantage of advanced type theory in your everyday job. Sometimes, it's hard to see the forest for the trees. Languages like Idris are excellent for reasoning about typing. You can build a type model in Idris and adapt it to a language like C++.

Now in print and shipping from pragprog.com/book/7lang.

Upcoming Author Appearances

Don't Get Left Out

Are your friends jealous that you get these spiffy email newsletters and they don't? Clue them in that all they need to do is create an account on pragprog.com (email address and password is all it takes) and select the checkbox to receive newsletters.

Are you following us on Twitter and/or Facebook? Here's where you can find us and keep up with the latest news and commentary, and occasional discounts:

Tell your friends! Tweet this

Follow us on Twitter: @pragprog, @pragpub, Andy @PragmaticAndy and Dave @pragdave.

Dave & Andy
The Pragmatic Programmers

Books • eBooks • PragPub Magazine • Audiobooks and Screencasts
PragProg.com

Manage your subscription using your account, or permanently unsubscribe here.
Sent by the Pragmatic Programmers, LLC. • 2831 El Dorado Pkwy, #103-381 • Frisco TX 75033