Contents of Recent Issues

September 2017

What’s in this issue? Three code-rich feature articles, a thoughtful essay by Ron Jeffries, and contributions from our regular contributors.

All this year Venkat Subramaniam has been teaching us how to refactor our Java code to functional style, taking advantage of functional features in Java 8. This month Venkat looks at common operations for processing text files in the imperative style and then explores how to perform those operations in the functional style.

Josh Stella, Chris Grim, and Jasper Van der Jeugt work at Fugue, whose product, also called Fugue, automates cloud operations. You could call it an operating system for the cloud. An operating system needs a system language, and for Fugue that’s Ludwig. If you’re curious what a language for managing the cloud looks like, their article in this issue should satisfy your curiosity.

I worked with Dmitri Sotnikov on his book Web Development with Clojure and can testify that he’s a bonifide expert on using Clojure to build websites. This month he gives a hands-on explanation of how to use Re-Frame, a tool that improves performance by virtualizing the DOM and leveraging the power and ease of use of a modern functional language.

Ron Jeffries has been developing software longer than most people have been alive. He holds advanced degrees in mathematics and computer science, both earned before negative integers had been invented. His teams have built operating systems, compilers, relational database systems, and a large range of applications. Ron’s software products have produced revenue of over half a billion dollars, and he wonders why he didn’t get any of it. This month he explores an idea that could be a driver for successful software development in the Agile style.

Also in this issue, Johanna Rothman writes about accounting for performance with flow efficiency; Antonio Cangiano find a book on concurrency in the Go language that he likes, as well as 29 other new programming books you should know about; and John Shade offers his thoughts on the dangers of facial recognition.

We hope you enjoy it!

August 2017

In ancient times, meaning the 1960s and 70s, writing code that involved floating-point calculations was like navigating a minefield. Different computers had different ideas about rounding and precision, and when it came to comparing values, they all had quirks that would produce incorrect and downright crazy results at times.

Things are a lot more stable now, because programmers got together and, over the years, developed an IEEE standard for how floating-point math should work.

Normalized and denormalized, zero and negative zero, infinity and negative infinity, Quiet NaN and Signalled NaN, ULPs and biased exponents, it’s all standardized. In this issue, Jim Bonang digs right down to the bit patterns in explicating the intricacies of comparing floating point numbers — and along the way explores the origins of virtual reality, in a meaty article that is both deep and entertaining.

All this year in PragPub Venkat Subramaniam is showing how to refactor your Java code to functional style by taking advantage of functional and declarative features of Java 8. It’s really a great tutorial on how to rethink problems from a functional perspective, regardless of language.

This month he shows how much time and effort can be saved by using the more advanced builtin functions of a language rather than falling back on primitive functions. Avoiding this common anti-pattern, primitive obsession, pays off especially well in functional languages, which pack a lot of power into their higher-level functions.

Most people tasked with hiring programmers would probably agree that asking an interviewee to write a Quicksort on the whiteboard while you watch is dumb. And most would also agree that the ability to understand algorithms is something you want to test for. Is there a better way to do algorithms interviews than the way we’ve been doing it?

Jay Wengrow thinks there is, and shares it with us this month.

Frequent contributor Erica Sadun has been tracking the development of the Swift language, and shares some nifty tricks you can do with the latest features in Swift 4.

Regular columnists Johanna Rothman, Marcus Blankenship, Antonio Cangiano, and John Shade are on board as well. It’s a jam-packed issue. We hope you enjoy it!

July 2017

Chris Crawford was at one point the best-known computer game developer on the planet. That was back when he was training game developers at Atari under Alan Kay, launching and running the Game Developers Conference, editing and writing much of The Journal of Computer Game Design, writing The Art of Computer Game Design, and collecting royalties on best-selling games like Balance of Power.

Then one day he gave a famous speech that ended with his drawing a sword and running out of the room shouting “Charge!” and never returning. He was off to fight the dragon. From that point on he dedicated himself to the quixotic quest to create a new kind of computer game, a new approach that didn’t glorify combat and small-muscle skills, that was built around realistic human emotions and interactions.

He’s still at it, and he recently released a tool that he thinks might be a key component of that new kind of software. It’s an editor for character interactions. It’s fun to play with, and it suggests interesting applications. Chris sees his new kind of game as more than entertainment: it’s interactive storytelling, it’s sales training, it’s a new category of software. Or it will be, if he manages to slay that dragon. This month we report on his quest and this new tool for editing interactions.

You can also read that article for free at the Prose Garden website. We’re hoping to offer more free content in the coming months.

Also in this fat July issue of PragPub are an entertaining and rich essay on floating-point gotchas by Jim Bonang, the final wrap-up of Mark Pearl’s series on Mob Programming, the latest in Venkat Subramaniam’s series on refactoring to functional style in Java 8 (this time focusing on the Execute Around Method pattern), and Erica Sadun on new capabilities and tricks in Swift.

Of course columnists Marcus Blankenship, Johanna Rothman, Antonio Cangiano, and John Shade contribute to the issue, your editor shares some tech news, and there’s a bit of advice on writing from Derek Sivers.

We hope you enjoy it!

June 2017

Welcome to the June, 2017, issue of PragPub! This month zombies come to the rescue, we learn the virtues of mobs, and encounter a brighter Ruby, among other exciting adventures.

Crystal is an elegant high-level programming language created in 2011. It draws inspiration from Rust, Go, C#, Python, Elixir, Erlang, and Swift, but especially Ruby. In fact, Crystal is Ruby, but with a static type system. Compiled to machine code through the LLVM toolchain, Crystal is very fast. It combines the high-level coding of dynamic languages with the safety and blazing performance of a natively compiled language. This month, Ivo Balbaert introduces Crystal and shows some of the ways it is like and unlike Ruby.

People new to Test-Driven Development often struggle to come up with the right tests. It’s hard to know where to start or what test to write next. It’s also hard to know when you’re done, and scary to think you will leave some incomplete code behind. James Grenning has come to rely on zombies to fight these scary problems. That’s ZOMBIES, an acronym and a way of deciding what tests to write and when. James reveals all about ZOMBIES in this issue. With ZOMBIES, you need never be afraid of testing again!

In Java, we’ve been writing object-oriented code using the imperative style. Starting with Java 8, we can write code in the functional style. All this year, Venkat Subramaniam is demonstrating how to refactor existing Java code to take advantage of its functional features. You’ll learn why and how to refactor your code to functional style. This month, Venkat focuses on the functional approach to one of the most common operations on data: grouping.

For a few months now in PragPub, Mark Pearl has been exploring practical issues in implementing mob programming. His articles are all based on problems that have come up in his own experience with mob programming or in consulting with others on their mobbing efforts. This month he deals with the problem of introducing a newbie to mobbing.

And there’s a lot more. Johanna Rothman on cadence, Marcus Blankenship on the unexpected, Antonio Cangiano on new tech books, your editor on tech news, and John Shade on a topic he refuses to reveal at this time.

But no worries, all will be made clear in this June, 2017, issue of PragPub.

We hope you enjoy it!

MAY 2017

Welcome to the May, 2017 issue of PragPub! Our lead article is from familiar contributor James Bonang. In it, the unexpected discovery of a venerable artifact leads Jim to examine tools and techniques that can help you eliminate memory errors in C++ code. It’s the first installment in an occasional series on building quality software. You’ll save time, effort and maybe a project or two.

In Java, we’ve been writing object-oriented code using the imperative style. Starting with Java 8, we can write code in the functional style. All this year, Venkat Subramaniam is demonstrating how to refactor existing Java code to the functional style. You’ll learn why and how to refactor your code to functional style. This month, Venkat focuses on the functional approach to one of the most common operations on data: sorting.

Woody Zuill, the creator of Mob Programming, steps in for vacationing Mark Pearl, who has been writing about practical issues in implementing your own mob. This month Woody looks at the productivity question at the heart of mob programming: How can five people at one computer be productive?

You’re a developer, but at some point in your career you’ll probably find yourself managing others. Every month Marcus Blankenship shares tips on how to be as good at managing as you are at your “real” job. This month is a double-header as he looks at two management challenges: the programmer who just wants to program and the programmer who insists you need to halt forward progress and rewrite or refactor crufty code.

What else? Antonio Cangiano returns with another selection of new books on programming, John Shade gets as touchy-feely as he’ll ever be as he takes on the challenge of Grasping, and we have not one but two brain teasers. All in this May, 2017 issue of PragPub.

We hope you enjoy it!

APRIL 2017

LOOKING AT LOW-CODE

* What Is Low-Code?
* Low-Code Mobile Development
* Mob Programming vs. Pair Programming
* Refactoring to Functional Style in Java 8

Plus: On Tap, Swaine’s World, New Manager’s Playbook, Johanna on Managing Product Development, Antonio on Books, The BoB Pages, Shady Illuminations

What if you could get the same work done with a tenth the coding effort?

Low-code is an increasingly popular approach to programming that leverages visual development tools and third-party infrastructure so you can focus on the ten percent of your app that is unique. A low-code development platform bundles together all the tools you use into a unified experience that lets you build your application visually. Then once it’s built, the platform handles the full lifecycle, through test, production, and ongoing maintenance. It’s especially appealing for mobile app development, where time to market is king.

This month in PragPub we explore the low-code experience in two articles. First, Matthew Revell details just what low-code is and how you work in a low-code environment. Then Stanley Idesis walks you through a full hands-on example of mobile development on a low-code platform. Is low-code right for you? At the end of these articles you’ll know all you need to know to decide whether you need to give it a try.

Mob programming is an extrapolation from pair programming. If two programmers working together at the same computer on the same program is good, maybe a mob of programmers working together at the same computer on the same program is better. Mob programmers don’t usually claim that mob programming is necessarily better than pair programming, but rather that it has different advantages. But Mark Pearl claims that it does have some definite advantages over pair programming, and he lists and explains them in this issue.

All this year Venkat Subramaniam is writing about refactoring iterative code to functional style in Java 8. This month his series focuses on joining values, which he explores in three increasingly challenging before-and-after refactoring exercises. The lessons he’s teaching here will make your code better, no matter what language you’re working in.

And you’ll find all the regular features you expect in this month’s PragPub. Johanna Rothman is talking about how to talk to your boss, while Marcus Blankenship is talking about how to talk to your team if you’re the boss. Antonio Cangiano is excited about learning the technology underlying cryptocurrency, while John Shade is skeptical about chatbots. And the editor has pulled together some interesting science and tech stories from the last month, along with a tech-oriented puzzle.

MARCH 2017

* Beyond Functional Programming with the J Programming Language
* Two more articles on J and its ancestor, APL
* Refactoring to Functional Style in Java 8
* Mob Programming

Plus: On Tap, Swaine’s World, New Manager’s Playbook, Johanna on Managing Product Development, Antonio on Books, The BoB Pages, Shady Illuminations

Between an exploration of the realizable fantasy of sailing between the stars and a skeptical look at the questionable dream of making refrigerators smart, the March issue of PragPub covers a lot of ground.

Mark Pearl returns with more adventures in mob programming, the extrapolation of pair programming that brings the wisdom of crowds to coding. Mark’s series is all about giving you real hands-on experience in what it takes to get a team started with mob programming, and this month he tackles four common challenges likely to be faced by any team new to mobbing.

Following the advice in The Pragmatic Programmer, we like to examine new or unfamiliar programming languages every so often, and this month we’re digging into Kenneth E. Iverson and Roger Hui’s array language, J. The article by Adam Tornhill aspires to show you a programming language different enough to affect the way you view code, as well as presenting a new paradigm that might even alter your problem-solving abilities by reshaping the way you think about problems. We’ve supplemented it with a couple more short articles on J and its parent language, APL.

Adam’s article is titled “Beyond Functional Programming,” and you’ll have to read it to see just how J goes beyond the functional paradigm. For an article that goes right to the heart of functional programming, we offer Venkat Subramaniam’s “Refactoring to Functional Style in Java 8.” Venkat is writing about refactoring Java code to functional style all this year, and in this month’s article he refactors a piece of code that picks an element from a collection. The transformation takes code that was verbose and fluffy and makes it crisp, concise, and expressive. But Venkat shows that the change is about a lot more than code elegance.

Johanna Rothman has some advice on your project portfolio and on how to effectively say “No” to your manager when the portfolio is getting out of control. Marcus Blankenship talks about how not to say a certain unhelpful word to your team if you are the leader, and how to discourage others from using it if you’re not. Antonio Cangiano presents a rundown on the latest tech books, John Shade grumbles about products that shouldn’t be so darned smart, and your editor covers some recent developments in the tech world and offers up a puzzle.

We hope you enjoy it!

FEBRUARY 2017

* Liberation from the von Neumann Style
* Refactoring to Functional Style in Java 8
* Mob Programming

Plus: On Tap, Swaine’s World, New Manager’s Playbook, Johanna on Managing Product Development, On Writing for Us, On Writing Well, Antonio on Books, The BoB Pages, Shady Illuminations

“By the early 1960s,” Wikipedia informs us, “computer designs were approaching the point of diminishing returns. CPU speeds appeared to be reaching a plateau.” One way computer designers tried to solve the problem was through parallel computing, and one notable implementation was ILLIAC IV, an SIMD parallel machine delivered to NASA Ames Research Center at Moffett field in Mountain View in 1971. Stanley Kubrick visited the lab where it was being built and ILLIAC IV became the inspiration for the HAL 9000 computer in “2001: A Space Odyssey.”

The more things change, the more they stay the same. Around the same time this was happening, Intel co-founder Gordon Moore articulated what became known as Moore’s law: the number of transistors per chip would double every twelve months. Other important measures, like execution speed, seemed to scale with this. Later Moore had to stretch the timeframe, though, and before long it was clear that Moore’s law was not going to rule forever. Computer design had hit another plateau, and some solution had to be found to move forward.

Semiconductor designers turned once again to parallelism. They designed multiple processor cores within a single chip. Making use of these multiple cores, well, that was left as a software problem.

Today we’ve gotten a lot more sophisticated about how to recast problems for parallel solution, and we’ve also moved beyond the single-computer model of application software, with web apps and cloud computing. Interestingly enough, these new models seem to be particularly welcoming to parallel approaches.

And parallel approaches invite functional programming. This month, Hal Fulton reflects on functional programming, parallelism, and the future of computing.

Also in this issue, Venkat Subramaniam continues his series on refactoring iterative code in Java 8 to functional style. This month he focuses on the functional (and conceptually parallel) approach of treating collections as objects to manipulate directly, rather than piece-by-piece.

Parallelism can be implemented at the human level, too. Mark Pearl returns this month with the second installment in his hands-on series on getting into mob programming. With the preliminaries out of the way, he takes you right through your first mobbing session.

Marcus Blankenship writes for us on being a team manager or leader, about the mistakes you make the first time you are given responsibility over others, and how to avoid them. This month he talks about the importance of getting feedback from your team, and ways to invite it. Johanna Rothman writes on managing product development, and this month looks at what to do when some members of your team are not members of your team. Plus Antonio Cangiano has all the latest tech books and John Shade casts shade on the phenomenon of the perpetual beta.

And one more thing: writing. You’re obviously a reader, and we suspect you may also be a writer. If you have an idea for an article or a book, we want to hear from you. Toward that end, Derek Sivers and I have pulled together some advice on writing articles for PragPub, writing books for The Pragmatic Bookshelf, and writing in general.

It’s a fatter-than-usual issue. We hope you enjoy it!

JANUARY 2017

PragPub has always embraced the move to functional programming, and this year we will share hands-on examples in every issue of how to refactor imperative code to the functional paradigm. Java 8 supports writing code in functional style, and Venkat Subramaniam has agreed to a twelve-issue series on refactoring to functional style in Java 8, to appear throughout 2017. He’ll delve into topics like lambdas and legacy code, find first and find any, joining, sorting, grouping, and infinite streams. This month he dives right in, showing how and where you can use lambdas directly in legacy code, as well as where and why you should.

We’re starting another series this month, as Mark Pearl begins a practical introduction to mob programming. Mob Programming is a new and interesting software development technique in which a group of people work at one computer solving one problem. It can be seen as an evolutionary step forward from Pair Programming. When you finish Mark’s introduction, you’ll have what it takes to get a team started with Mob Programming.

Johanna Rothman shares her experience on building to learn and learning to build. Marcus Blankenship shares secrets of great one-on-one meetings. Antonio Cangiano has collected all the new tech books of interest. And your editor has gathered some tech news highlights of the past month, along with a puzzle and assorted other choice bits. Oh, and we’ve put together a complete index to all articles from 2016.

But wait — there’s more! Onorio Catenacci and Derek Sivers return to PragPub with thoughts, whimsical and outside the box, on interviews and motivation. And John Shade, who took all of 2016 off for mysterious purposes, is back with some thoughts on what made America great.

We hope you enjoy this first issue of 2017!

DECEMBER 2016

This issue features Apple’s Swift language, with code-rich articles from three savvy Swift practitioners.

Erica Sadun, author of the forthcoming Swift Style from the Pragmatic Bookshelf, poses a puzzle for the reader, focusing on matrix math, translations, rotations, concatenations, and other polysyllabic perturbations.

Janie Clayton, co-author of iOS 10 SDK Development, contributed two articles to the issue. In one, she works through a case study of working within Swift with a legacy C library, and shows that even when you’re hiding that C code in a nice Swift wrapper, you still have to think like a C programmer. In the other, she works through one problem two ways: as solved in the pre-Swift days, and as solved today. In the process, she comes to appreciate the importance of rethinking the entire problem in the light of modern paradigms.

And Natasha Murashev, whose Swift articles have appeared here before, offers a caution about a Swift feature that can easily be misused — with unfortunate consequences.

If you’re a manager or have ever led a team, you may be able to cite cases where you really connected with a team member, heard their issue, gained their trust, and empowered them to do their best work. Maybe you can cite a lot of such instances. And then maybe there are those team members you didn’t have such great rapport with. You kept it more professional, and didn’t intuitively trust them to get it right.

If so, your problem was bigger than a less-than-perfect relationship with those employees. You had a structural problem with your entire team, because you created an in-group and an out-group. Without meaning to, merely because you were in a position of power, you replicated high school.

How do you, as manager or team lead, avoid creating cliques in your business or team? Marcus Blankenship has been there and has solved that problem, and he shares his insights with you this month.

In her column on managing product development this month, Johanna Rothman shares three powerful agile techniques. Even if fully embracing agile practices doesn’t work for your project, you should consider these three techniques that can benefit any task.

And there’s more: Antonio Cangiano has all the new tech books, your editor has the latest tech news, and we have another puzzle for you, as well as the conclusion to our series on Ted Nelson and his 50-year project Xanadu. We hope you enjoy it.

NOVEMBER 2016

Derrick Schneider is an old friend of the Pub. He modestly calls himself “a programmer, writer, and enthusiastic geek.” As a programmer, he’s comfortable with Erlang, R, Python, Ruby, Objective-C, and a number of cloud technologies. As a writer, he discussed wine with erudition and wit for years in the San Francisco Examiner. And his lead article for us this month shows his geeky side. You probably use GitHub, but you may not know about all the power GitHub offers through its extensive REST API. Derrick has explored it thoroughly, and shares some ideas for turning that API into a potent tool for your automation utility belt.

Antonio Cangiano has three (!) contributions to this issue. In addition to his monthly roundup of new tech books, we have his article on using programming to teach (or visualize) mathematical concepts. And he’s also offered up a short essay on blogging. Antonio wrote (and your editor edited) the excellent Technical Blogging [U1], so he knows all about why and when and whatabout you should be blogging.

It’s clearly old friends month at the Pub, as longtime contributor Andy Lester is back with a career-oriented article on how to sell yourself and your skills. Andy has been a regular columnist and a feature writer for us and had an article in the very first PragPub, back in the Precambrian era.

Regular columnists Johanna Rothman and Marcus Blankenship offer up more career advice, and your editor weighs in with a few contributions, including an appreciation of personal computer publishing pioneer David Bunnell and another installment in his series on Ted Nelson and Xanadu. Plus tech news and a puzzle. We hope you enjoy the November issue of PragPub!

OCTOBER 2016

This month in PragPub we’re featuring an excerpt from a new book by John Whitington. A Machine Made this Book: Ten Sketches of Computer Science introduces key topics in computer science to the literate lay reader. “What exactly is a computer program, what and how does it calculate, and how can we build one? Can we compress information to make it easier to store and quicker to transmit? How do newspapers print photographs with grey tones using just black ink and white paper?”

John knows his stuff: he’s the founder of a company that builds software for electronic document processing and he has taught Computer Science at Queens’ College, Cambridge.

Although the book is aimed at novices, the treatment is serious and deep. It would be an enjoyable read for any programmer, a useful tool to have at hand when explaining computer science topics to novices, and a fine example of writing about technology. We think you’ll enjoy his deep dive into the history and technology of reproducing grey tones that we’ve excerpted here.

Also in this issue: Andy Lester shares his thoughts on how to do estimates when you absolutely have to do estimates, Marcus Blankenship talks about the fundamental importance of good personal relationships in software teams and how to foster them, Johanna Rothman explains why technical debt can be a distracting and damaging metaphor, Antonio Cangiano rounds up the latest technical books, and Mike summarizes the tech news of the past month.

And that’s not all: that series on Ted Nelson and Xanadu returns, and we have a puzzle for you to solve. We hope you enjoy this October issue.

SEPTEMBER 2016

Martin Fowler. Derek Sivers. Swift programming. Boiled Carrots. Several cautionary lessons on the perils of sharing your knowledge. In the September PragPub.

Part of every professional’s work is teaching. It could be in a formal classroom setting or a talk at a conference or user group, it could be the guidance you give a new team member or the feedback you give in pair programming, it could be suggestions or praise you offer as a manager or team lead, it could be in your documentation or in a blog post or an article in a programming magazine. One way or another, you spend a significant part of your time sharing the knowledge and expertise you’ve acquired. And it’s not trivial to do it well.

The problem, as Swizec Teller explains in our lead feature, is that you know more than you think you do. And that makes it hard to recognize what others don’t know. Peter Jang points out how your clean, well-crafted code is not necessarily the best code for teaching purposes. The good news is that he shows you how to turn good code into teachable code.

When you’re in a management or tech lead role, everything you do is teaching. Your biggest challenge may be not teaching the wrong things. Marcus Blankenship write about the promises you make without realizing you’re making them. He shows how to recognize these situations so you can avoid breaking a promise you never knew you made. Another thing you may be doing without realizing it is stealing credit when all you think you’re doing is putting in your two cents. Derek Sivers explains how to avoid that mentoring mistake.

Cultural and gender differences shouldn’t get in the way of sharing your knowledge, but we know that they often do. Natasha Murashev shares her own experience with the diversity challenge in software development, and talks about ways to address it.

Natasha actually has two articles in this issue. She’s one of our go-to experts on the Swift language, and she shares her expertise with us this month in an article on Protocols with Associated Types. In keeping with Swizac’s insight, she discovered that her audience at a recent talk didn’t know as much as she expected, and the result was this article.

And there’s more. Regular columnist Johanna Rothman returns with advice on how to say no in a way that management can understand — and accept. And programming legend Martin Fowler shows that sometimes the problem isn’t where you think it is. And as usual, Antonio Cangiano has all the new tech books and your editor offers his review of recent developments in tech and serves up a puzzle. We hope you enjoy the issue.

AUGUST 2016

Space travel has come — or should that be “gone?” — a long way since Yuri Gagarin and Alan Shepard were launched into space in the spring of 1961.

But even back then a rocket launch required a complex set of systems to successfully lift the vehicle on its journey. So does your project. Master coaches Diana Larsen and Ainsley Nies have successfully “lifted off” numerous agile software projects worldwide. This month in PragPub, they reveal their techniques for successful liftoffs.

Also in the August issue, Jeff Heon offers a gentle introduction to the F# language, which turns out also to be a friendly tutorial on recasting solutions in functional programming style.

Haskell is another language designed with functional programming in mind, but Paul Callaghan’s Haskell-based article goes beyond any single language or paradigm for a deep dive into the subject of subtyping. You think you know what types are, but Paul will demonstrate that you had no idea of the power of the construct of the subtype. It’s a lesson in how academic computer science can deliver new and powerful techniques for practical programming.

Mike picks up his series on computing pioneer Ted Nelson this month, sharing the moment in the development of Xanadu when some of the key pieces of its software were developed. He also introduces some key players in the Xanadu story.

Marcus Blankenship has another cautionary tale of bad software team management decisions, Johanna Rothman explains why your third-grade teacher was right about the need to show your work, Antonio Cangiano has another batch of tech books, and Mike summarizes what happened in the world of programming in the past month.

JULY 2016

This month, we’re celebrating seven years of PragPub with a big fat issue. In addition to regular columns by Johanna Rothman, Marcus Blankenship, and Antonio Cangiano, we’re serving up a double helping of eight (8!) feature articles, and we’ve invited some old friends to help us celebrate with articles that look back on where we came from and forward to where we might go…

Alistair Cockburn shares some thoughts on the Agile Manifesto and how it came about. Another Manifesto author, Ron Jeffries, reflects on the Extreme Programming philosophy. Allen Holub weighs in on #NoEstimates and Johanna Rothman gives some advice on dealing with estimates when no is not an answer.

Michael Nygard sorts the unicorns from the dinosaurs and concludes that the software of the future needs to be fleet of foot and highly disposable. Suppose software were trivial to create and only ever needed to be used once. Completely disposable. What would that mean to the way we write it? And what would it take to make that a reality?

And then there’s testing. Test-Driven Development has transformed how we (at least for some values of “we”) program. Three experts in testing and development weigh in on TDD this issue: Jonathan Rasmusson, Jeff Langr, and Venkat Subramaniam. The explore the testing pyramid, the virtues and benefits of TDD, and some of the barriers to implementing TDD.

Also, Natasha Murashev has been getting to know the Swift language and shares a practice she’s worked out for bending the language to her needs. It’s totally wrong, it’s not how you’re supposed to do it — but it works. Plus there’s Antonio with all the latest tech books and your editor with his review of the highlights of the past month in tech. And a puzzle. And a poem. Because it’s our anniversary!

JUNE 2016

This month in PragPub we’ve got advice for young programmers and programmers-turned-managers and seasoned developers, code projects in JavaScript and Elixir, some forward thinking on testing, and a game for you to build.

Elixir is catching on as a rich and friendly language for general business development. But evolution in the Elixir ecosystem is not uniform. On area where it’s lagging is testing, and Bruce Tate wants to fix that. This month he offers a tool for testing Elixir code based on a well-thought-out philosophy of testing.

If you’re building for the Web today, you want to make sure your app performs superbly with mobile browsers. That’s the priority of the folks behind Phaser, a JavaScript framework for creating games that run in your browser or on mobile devices. Brian Hogan has been playing around with it and walks you through the basics by developing a complete simple 2D game. With Phaser handling the creation of states, collisions, sprites, and the like, you can concentrate on the features that make your game unique and fun for the player — and have fun building it.

Software development is experiencing a population explosion. We tend to address experienced developers in PragPub, but we aren’t oblivious to the fact that there are lots of new programmers who would like a little helpful advice from seasoned veterans. Last year Antonio Cangiano interviewed over 100 candidates for IBM and ended up hiring a couple dozen of them. In this issue he shares what he wanted to tell all of them in his tips for young programmers.

Experienced programmers can benefit from advice, too. In her new column, Johanna Rothman shares two stories from in the trenches and explains how to take control of your project portfolio. Columnist Marcus Blankenship continues his series on bad management habits. Antonio also shares his list of new books in technology. And Derek Sivers offers some advice on looking for the intersection between happy, smart, and useful.

MAY 2016

This month in PragPub we cover a lot of ground, from Apple Watch to Windows, from legacy C code and shell scripts to Haskell and Elixir programming, from testing code to managing programmers to strategies for dealing with an uncertain world.

Aaron Bedra introduces a more advanced form of testing that can be extremely useful and he does it using a higher level language, Haskell, to test some lower-level legacy C code. Although you’ll learn a bit about Haskell from the article, the powerful testing technique it introduces can be used in your language of choice.

Onorio Catenacci also uses a modern language to solve a legacy problem: the age-old problem of Windows file names. If you work in the Windows world, sooner or later you’re going to trip over the problem of paths that have spaces or that are longer than eight characters. Onorio is exploring the Elixir language these days and the problem cropped up while he was improving the functionality of the Elixir Release Manager (exrm) on Windows. So he built a tool to solve the problem, and his report on his experience is a hands-on introduction to working with Elixir.

Jeff Kelley has been developing for Apple Watch for some time now and has discovered some best practices and gotcha avoidance tips for Watch developers. He shares them with us this month.

But there’s more to the life of a programmer than writing code. Rothman and Lester offer up some advice on what to do when your job is making you unhappy, Marcus Blankenship gives advice on how not to make your employees unhappy on the job, and Derek Sivers advises on how to deal with an uncertain future.

Also, Mike continues his series on Ted Nelson, Antonio Cangiano queues up all the new tech books, and we toss you another challenging puzzle. We hope you enjoy it all.

APRIL 2016

The folks who rank programming languages for popularity have been placing Python in the top ten for over a decade. It’s the language of choice for many programmers in scientific programming, AI and natural language processing, and web app development. It’s the language Google App Engine was designed for, and is officially the principle user-programming language for Raspberry Pi. It’s everywhere.

Python’s creator, Guido van Rossum, who is still actively involved in its development, designed Python to be highly readable, using whitespace indentation and English keywords where other languages use punctuation. We think Python is pretty magical and we wanted to share some Python magic with you this month.

The test of the seriousness of any programming project is the seriousness of its testing. This month Brian Okken takes us on a tour of testing in Python with two articles. First he works through some of the factors you need to weigh in choosing a test framework for Python. Then he shows the advantages of one approach to testing in Python, drawn from Behavior-Driven Development.

Python is popular in research for good reasons. Dmitry Zinoviev reveals some of those reasons in his article on analyzing cultural domains with Python. You’ll find it a good introduction to the techniques of data exploration and analysis used in social science research as well as an introduction to some of the goodies built into the Python language, in case you haven’t yet made the Python plunge.

Sometimes the best decision you will make all day is not to do something. This month our columnists have some advice for you on things not to do. Andy Lester and Johanna Rothman discuss what not to do (and a few things to do) when you lose your job. Marcus Blankenship has some advice about what he calls “management smells”: bad management habits that you should watch out for. In a guest viewpoint, Dan Frost describes some hidden biases to avoid in making decisions in programming projects. And Antonio Cangiano offers up a list of new tech books that are not to be missed.

Finally, we have another installment in our series on the life of hypertext inventor Ted Nelson. This month we catch up with Ted in the 1960s, jamming with David Crosby in coffeehouses, making a dolphin movie for John Lilly, and giving a crucial talk before the Association of Computing Machinery — a talk that laid out his Xanadu vision for the first time to people who could actually help Ted realize it.

MARCH 2016

This month we have two articles focusing on frameworks, but from very different perspectives. Dave Copeland presents a compelling argument for why you need a JavaScript framework. Even if you’ve already reached that conclusion, you might want to read Dave’s article in case you need ammunition to argue that case someday.
Ken Rimple takes a deep dive into Angular 2, the popular open-source web application framework maintained by Google and others. Specifically Angular 2 testing, which puts him out on the frontier of this new framework. He took a few arrows for you, and if you’re using or evaluating Angular, you’ll want to grab Ken’s insights and code.
Remember that great team you worked on that one time? Great people, a great project, you felt productive and happy. What if it were always like that? What if every team you worked on was a team you sought out because you wanted to work with those people on that project? That’s the inspiration behind self-organizing teams, an exciting idea detailed by David Mole and Sandy Mamoli in their book Creating Great Teams. This month they explain the basics of the process.
Of course, sometimes things don’t work out so happily. The company is downsizing and has to lay some people off. One of your coworkers isn’t cutting it and is let go. How do you handle yourself at work when people are fired or laid off? What should or shouldn’t you say? What should you do? Johanna Rothman and Andy Lester discuss just that in their column this month.
But what if you’re the manager and a new employee hasn’t delivered the performance you expected? How do you offer course correction without demoralizing a new hire? How do you set expectations for the work and show respect for the individual? Marcus Blankenship tackles that situation in his New Manager’s Playbook.
And there’s more. Your editor continues his series on Ted Nelson and how he came to invent hypertext and Xanadu, the Web the Way It Should Have Been. This month we go back in time to 1960 and Ted has the epiphany that will change his life.
Antonio Cangiano has all the latest tech books, we’ve put together a different sort of puzzle, there’s tech news, and other goodies. I hope you like it.

FEBRUARY 2016

This month our series on hypertext visionary Ted Nelson continues, focusing on Ted’s college years. It was there that his views on civilization and communication began to take shape. We sample some of the newspaper columns he was writing back then, and discover that the author of Computer Lib was already recognizable in Ted’s college writing. We look at some of his influences and discover exactly where and when he had the fundamental insight that led ultimately to Xanadu.

Ken Rimple has been working with Angular 2, the new and challengingly different version of the popular development platform for building mobile and desktop web applications. He quickly realized that there was a serious lack of samples of tests for developers. His article in this issue takes on that problem directly, with working code samples to get you going.

Metal is the low-level hardware-accelerated graphics API that Apple introduced in iOS 8. It’s designed to give you the lowest-overhead access to the GPU for graphics-intensive apps for iOS and OS X. As Janie Clayton says in her article this month, “It was the most exciting announcement of WWDC for approximately five minutes until Swift was announced.” Her article taps both those themes, showing how to build a template that can be used as a base to get Metal up and running.

Should designers know how to program? No, says Lukas Mathis, and he can defend his position. But there is one situation where he thinks differently. In this issue he explains when and why designers should acquire some developer knowledge.

In his column on the challenges of being a manager, Marcus Blankenship tells a story and presents a quiz. It’s all about what you should do when that hotshot programmer you just hired completes that first assignment — and it’s a disappointment. How you respond will shape the developer’s relationship with the job from that point forward. Would you know what to do?

Johanna Rothman and Andy Lester chat about open source projects in their career column this month. The most direct benefit in contributing to open source projects comes when you’re helping to improve the work products you use every day. But there are a lot of other benefits, including some you may not have thought of.

Also this month: Antonio Cangiano reports on thirty new tech books and your editor presents a puzzle and other goodies.

JANUARY 2016

Ted Nelson, functional programming in Swift, and the Wolfram Language goes to the cloud.

NOVEMBER 2015

This month’s PragPub features articles on functional programming, full stack development, programming your editor, and working on your career.

Clojure is a variant of the Lisp programming language, which means that it really is a different species of animal than you’re used to if you learned programming in an object-oriented, procedural paradigm. Getting good at Clojure means shifting mental gears and embracing a library-centered function-grounded worldview. In the first part of a two-part exploration of the language, Brian Marick will teach you how to think in Clojure.

This issue also features another installment in our year-long series on functional programming in Apple’s Swift language by Chris Eidhof, Wouter Swierstra, and Florian Kugler. This month they talk about smart uses of wrapper functions.

There’s a satisfaction in getting really good at using a tool, especially if it’s one you use every day. When that tool is your editor, it can make you significantly more productive, too. Ben Klein is back this month with another deep dive into the Vim editor. Totally mastering the power of your editor could be the most productive thing you can do as a developer.

Sometimes, though, total mastery of a skill or tool is overkill. David Copeland, author of Rails, Angular, Postgres, and Bootstrap, explains in this issue how to become a master full-stack developer by not trying to master every part of the job. The trick is knowing just enough about every aspect of web app development.

A related insight applies to how you approach your work in general. Derek Sivers encourages you to slow down a little and not try to squeeze out that last bit of speed or productivity. You’ll be surprised how much you achieve if you don’t try quite so hard, and you’ll be less stressed. Marcus Blankenship and Johanna Rothman and Andy Lester share advice on your career, too, while Antonio Cangiano reports on new tech books to enhance your skills, plus we’ve got a puzzle to exercise your mental muscles, and John Shade tells you what to fear.

OCTOBER 2015

In the mid-1970s, building on the early ed line editor for Unix, Bill Joy and Chuck Haley wrote ex, which was distributed with the first BSD version of the operating system in 1978. Joy enhanced ex into the visual editor vi, still in use today, the default Unix editor included in every POSIX-compliant system, from Linux to Mac OS X. But vi was built on top of ex commands — as Joy has said, “fundamentally, vi is still ed inside”. So ex still survives and is equally ubiquitous. The most widely used vi clone today is vim, originally developed by Bram Moolenaar.
The fact that vim has a command-line editor inside it has some interesting implications, which Ben Klien explores in our lead article this month, “Scripting Vim”. The compatibility of vim with ancient tools is remarkable, but more remarkable is what you can do with vim when you turn the compatibility off.

Introducing Ember

by Matthew White
Ember is an open source JavaScript framework designed to waste less time reinventing the wheel. The Ember project was founded to put “all of the best ideas in web development into one framework, and to help developers waste less time on boilerplate code.” Matthew White introduces Ember in this issue, and explains why you may want to look into Ember if you want your Web app to compete with native apps in responsiveness and usability.

Inheriting a Project You Know Nothing About

by Andrew Hunter
If the title sounds like a nightmare, read Andrew’s advice and the reality won’t be a nightmare when it happens to you.

Functional Snippets

by Chris Eidhof, Wouter Swierstra, and Florian Kugler
The next installment in our new series on functional programming in Swift.

And there’s still more: Rothman and Lester on interviewing. Marcus Blankenship on what a manager really does. Derek Sivers on how to say no to everything. Plus Antonio Cangiano has all the new tech books, John Shade tackles the Slow Code Movement, and we have a Sudoku/Anagram puzzle.

SEPTEMBER 2015

Adam Tornhill suggests you view your code as a crime scene. Testing has a lot in common with forensic science, and when you’re doing it you may find yourself thinking like a bad guy — or like a clueless user. Today, when you might be developing apps for a spectrum of mobile devices or building a high-traffic always-on ecommerce site, deploying in the cloud and tapping into remote web services or writing robot-control software for a single-board computer, the detective work of software testing is getting more diverse and subtle. This month we have two articles on testing, and links to almost two dozen more.

A Crash Course in Mobile Testing

by Keith Stobie
Keith focuses on testing for mobile development. Mobile app development is one of the main fields of software development today, and will just get bigger tomorrow. Testing is critical, but is often given inadequate attention in mobile development. Keith addresses this problem with a crash course in testing for mobile development.

Stepping Up to Simulation Testing

by Ryan Neufeld
Ryan makes the other end of the spectrum his own. He explains simulation testing, an approach ideally suited to large-scale production systems generating tons of revenue, where the stakes are high.

Further Reading on Testing

by PragPub Staff
But wait, there’s more: links to nearly two dozen articles we’ve published on testing.
Plus…

Making Computer Science Insanely Great

by Jim Bonang
Jim found himself thrown into an intense teaching situation, and drew inspiration and guidance from a variety of sources.

Functional Snippets

by Chris Eidhof, Wouter Swierstra, and Florian Kugler
The next installment in our new series on functional programming in Swift.

And there’s still more: Rothman and Lester on how to hire. Marcus Blankenship on how to let go. Antonio Cangiano has all the new tech books. And a Sudoku/Anagram puzzle.

AUGUST 2015

Woody Zuill knows a lot about Mob Programming. He characterizes it as “all the brilliant people working at the same time, in the same space, at the same computer, on the same thing.” If you’re not familiar with the technique, it probably sounds extreme. In fact, if you’re comfortable with Extreme Programming, Mob Programming might *still* sound extreme. The whole team working together on one task on one computer? How could that possibly be efficient? Woody is going to tell you how, in detail, in this month’s PragPub.
Also…

Making Computer Science Insanely Great

by Jim Bonang
Jim found himself thrown into an intense teaching situation, and drew inspiration and guidance from a variety of sources.

What Perl Still Gets Right

by chromatic
If you think Modern Perl is an oxymoron, you haven’t been keeping up with the developments in this Swiss Army knife of a language. The fourth edition of the classic Modern Perl is coming out soon, and its author, chromatic, took time out from wrapping it up to write an article for us on what Perl *still* gets right. Spoiler alert: it gets a lot right.

Functional Snippets

by Chris Eidhof, Wouter Swierstra, and Florian Kugler
The next installment in our new series on functional programming in Swift.

And there’s more: Rothman and Lester teach you how to write a job ad. Marcus Blankenship debunks some myths around managing by walking around. Antonio Cangiano has all the new tech books. There’s that Sudoku/Anagram puzzle. And John Shade takes on ad blockers.

JULY 2015

This month we have the first installment of a series on teaching kids to code, written by Jim Bonang with an assist from Clarisse Bonang, an actual kid. It’s really filled with insight and case-study experience, and if you’ve ever taught or wanted to teach or imagined yourself teaching someone of the kid persuasion how to code, you’ll get a lot out of it.

Making Computer Science Insanely Great

by Jim Bonang with an assist from Clarisse Bonang
Jim found himself thrown into an intense teaching situation, and drew inspiration and guidance from a variety of sources, including a special issue of PragPub on teaching kids to code.

Mutation Testing — Totally a Thing

by R. Michael Rogers
If you’ve ever had the feeling that you’re refactoring without a safety net, you need to know about mutation testing.

Making Time To Tend Code

by Rachel Davies
How do you explain to management the importance of those hours you spend — or need to spend, anyway — in activities that don’t move the needle in any way they can measure? How do you justify taking time away from adding features of upping the count of lines of committed code, to spend it on cleaning up the code you have, tending the garden that is your codebase?

Functional Snippets

by Chris Eidhof, Wouter Swierstra, and Florian Kugler
The next installment in our new series on functional programming in Swift.

And there’s more: Rothman and Lester discuss the importance of understanding what sets you apart from the crowd. Marcus Blankenship shares the one thing you have to learn when you make the leap from lead programmer to owning your own agency. Antonio Cangiano has all the new tech books. There’s that Sudoku/Anagram puzzle. And John Shade redefines the Internet of Things.

JUNE 2015

It was the Woodstock of computer technology. Everybody wishes they had been there, and one suspects that a lot of people who weren’t have convinced themselves that they were. In this issue: the Mother of All Demos and the unfinished revolution of Doug Engelbart.

Hello Again, Android!

an interview with Ed Burnette, author of Hello, Android!
Android is inside over a billion cell phones and other mobile devices, making it the number one platform for application developers. Ed Burnette wrote the book on Android development, and he recently released the fourth edition of Hello, Android So we collared him for a free-ranging interview on Android, his book, and programming in general.

Paul Learns To Parse

by Michael Bevilacqua-Linn
Michael explores the development process while working through the steps of writing a parser in an engaging two-part series concluding this month. It’s the story of product development actually told as a story. Along the way, you’ll follow the refinement of an algorithm.

Unfinished Revolution

by Michael Swaine and Paul Freiberger
Knowing where you came from can help you avoid past mistakes and plot pathways to the future. This month we conclude a two-issue series focusing on two genuinely revolutionaries. Ted Nelson and Douglas Engelbart both plotted paths to a better future, both promoted revolutionary change, and both their revolutions remain unfinished.

Functional Snippets

by Chris Eidhof, Wouter Swierstra, and Florian Kugler
The next installment in our new series on functional programming in Swift.

And there’s more: Rothman and Lester discuss networking to find jobs: how to do it, when to do it, and why it isn’t sleazy or distasteful. Marcus Blankenship has some advice on how to keep little annoyances with employees from growing into chronic problems or even explosive situations. Antonio Cangiano has all the new tech books. There’s that Sudoku/Anagram puzzle. And an index to the past six issues of PragPub.

MAY 2015

It’s an Amaze-ing May issue!

Unicursal Mazes and Space-Filling Curves

by Jamis Buck
Jamis shows you how to create mazes. Why mazes? The underlying algorithms are entertaining to research and implement, and the results are pleasing to look at, but the bankable value comes from the play and experimentation, which increase your experience and grow your intuition.

Paul Learns To Parse

by Michael Bevilacqua-Linn
Michael explores the development process while working through the steps of writing a parser in an engaging two-part series starting this month. It’s the story of product development actually told as a story. Along the way, you’ll follow the refinement of an algorithm.

Unfinished Revolution

by Michael Swaine and Paul Freiberger
Knowing where you came from can help you avoid past mistakes and plot pathways to the future. This month we begin a two-issue series focusing on two genuinely revolutionaries. Ted Nelson and Douglas Engelbart both plotted paths to a better future, both promoted revolutionary change, and both their revolutions remain unfinished.

Functional Snippets

by Chris Eidhof, Wouter Swierstra, and Florian Kugler
The next installment in our new series on functional programming in Swift.

And there’s more: Rothman and Lester share six painful truths about programming in the real world that you don’t learn in school. Marcus Blankenship writes about coming to grips with what your team really needs from you when you step up to management. We’ve got another short example of Swift code. John Shade examines the examined life. Antonio Cangiano has all the new tech books. There’s that Sudoku/Anagram puzzle. And a list of algorithms you really ought to know.

APRIL 2015

You’re thinking, like Lewis Carroll’s White Rabbit, that you don’t want to be late to the party. You’re checking your Watch and imagining the apps you’ll develop for it. But before you follow the fuzzy fellow down the rabbit hole, maybe you should pause to think about this new Apple Watch programming opportunity.

A Timely Essay on Apple Watch App Development

by Jeff Kelley
Jeff writes about how to think about Watch apps, what to consider before you start coding — or even before you start imagining — your first Watch app. It’s an exercise in thinking in this new paradigm.

Meet the Social Side of Your Codebase

by Adam Tornhill
Adam shows you how the structure of your organization can be read out of the history of your codebase — and how that can help shape your thinking about your projects.

Rule #1 for Distributed Teams – The 2015 Edition

by Jeff Langr
Jeff, no stranger to the pages of PragPub, revisits his own coding history and finds it necessary to revise one of his basic principles. Along the way he shares some hard-won insights on how to make distributed development teams work.

Functional Snippets

by Chris Eidhof, Wouter Swierstra, and Florian Kugler
The next installment in our new series on functional programming in Swift.

Rothman and Lester

by Johanna Rothman and Andy Lester
Johanna and Andy offer sage advice on dealing with recruiters.

New Manager’s Playbook

by Marcus Blankenship
Marcus has some encouraging words if you’ve just made the transition to manager and are having some misgivings.

Antonio on Books

by Antonio Cangiano
Antonio’s got all the new tech books of note.

…and more.

MARCH 2015

Along with Swift, #NoEstimates, the first personal computer, and the care and feeding of your career, the relationship between patterns and craft is under scrutiny this month. Kent Beck knows a lot about programming, and a lot about patterns. He’s the author/coauthor of Implementation Patterns and The Smalltalk Best Practice Patterns, among his many publications and other accomplishments. He’s been giving a lot of thought recently to the relationship between patterns and craft, and he shares his thoughts with us.

Patterns Enhance Craft

by Kent Beck
Kent has been through the patterns-vs-craft fight and come out on the other side.

#NoEstimates Does Not Mean “No Estimates”

by Seb Rose
Sometimes the reason you’re not getting the answers you want is that you’re asking the wrong question. “How can I deliver better estimates?” is probably the wrong question.

The Voyage to Altair: Going for Broke

by Michael Swaine and Paul Freiberger
An excerpt from Mike and Paul’s history of the personal computer, Fire in the Valley, and part three of a series.
How a community of eager hobbyists made the MITS Altair a runaway success and launched the personal computer revolution. Oh, and a company called Microsoft.

Functional Snippets

by Chris Eidhof, Wouter Swierstra, and Florian Kugler
The next installment in our new series on functional programming in Swift.

Rothman and Lester

by Johanna Rothman and Andy Lester
Johanna and Andy look at the various social media platforms for presenting yourself to the world, and explain how to use them to best advantage.

New Manager’s Playbook

by Marcus Blankenship
For some reason, you just can’t seem to make the leap from programmer to management, and you don’t know why. Marcus can help.

Antonio on Books

by Antonio Cangiano
Antonio’s got all the new tech books of note.

…and more.

FEBRUARY 2015

Two languages for the future, two articles that evoke personal computing’s past, and timely advice for your career. Or to put it another way, Swift and Elixir, a retro game for the Arduino and the story of the MITS Altair, and regular columns by Andy and Johanna, Marcus, and Antonio.

Functional Snippets in Swift

by Chris Eidhof, Wouter Swierstra, and Florian Kugler
Continuing our series on functional programming in Apple’s Swift language.

Creating Elixir Test Data With Blacksmith

by Bruce Tate
Bruce goes all in with the new language, Elixir.

The Voyage to Altair: Going for Broke

by Michael Swaine and Paul Freiberger
An excerpt from Mike and Paul’s history of the personal computer, Fire in the Valley, and part two of a series.
How a community of eager hobbyists made the MITS Altair a runaway success and launched the personal computer revolution.

Building Shootduino

by Maik Schmidt
Maik was looking for a fun one-month project. So he built a retro space shooter game for the Arduino single-board computer. And he shares all the details here.

Rothman and Lester

by Johanna Rothman and Andy Lester
Andy and Johanna explain why Google’s job interview process probably means nothing to you.

New Manager’s Playbook

by Marcus Blankenship
Everyone hates annual reviews. Marcus explains how to make them work.

Antonio on Books

by Antonio Cangiano
Antonio’s got all the new tech books of note.

Shady Illuminations

by John Shade
John Shade casts his dark light on sex toys.

…and more.

JANUARY 2015

It’s January. Time to start learning a new language or programming paradigm. We have several suggestions for you…

Functional Snippets in Swift

by Chris Eidhof, Wouter Swierstra, and Florian Kugler
Launching a new series on functional programming in Apple’s Swift language.

A Testing Framework in Elixir

by Bruce Tate
Bruce goes all in with the new language, Elixir.

The Voyage to Altair

by Michael Swaine and Paul Freiberger
Ed Roberts was facing bankruptcy, his mail-order hobby electronics firm crushed in the calculator wars of the 1970s. His response was to take a very big risk on an obviously crazy idea. An excerpt from Fire in the Valley: the Birth and Death of the Personal Computer.

Turning APIs into Resources

by Tom Geudens
Resource Oriented Computing lets you build apps the way the Web is constructed. Here Tom shows how to turn APIs into resources, and why.

New Manager’s Playbook

by Marcus Blankenship
This month Marcus talks about how to manage up.

Rothman and Lester

Johanna and Andy reveal the questions not to ask in an interview.

Antonio on Books

Antonio’s got all the new tech books of note.

Shady Illuminations

John Shade casts his dark light on self-driving cars.

…and more.

DECEMBER

Resource Oriented Computing

This issue focuses on Resource Oriented Computing, an approach to software development that makes your apps work like the Web. Brian Sletten, Ron Hitchens, and Tom Guerdens will get you up to speed on the philosophy, principles, goals, and practice of ROC.

The History of Programming Languages

by Dan Wohlbruck
Dan continues his look at the C language, its roots, and its influence.

New Manager’s Playbook

by Marcus Blankenship
This month we launch a new column for everyone who has to manage others.

Rothman and Lester

Have you been stuck with training the new guy? Or maybe you *are* the new guy. What to do?

Antonio on Books

Antonio’s got all the new tech books of note.

…and more.

NOVEMBER

The Swift Language, customer support, crisis management, time management, and programming history.

The Philosophy of Great Customer Service

by Derek Sivers
CD Baby was a runaway success. It was all about how customers were treated.

The Many Faces of Swift Functions

by Natasha Murashev
Natasha covers the ground thoroughly, but swiftly.

Putting Down the Tools

by Marcus Blankenship
Don’t turn crisis management into crisis generation.

The History of Programming Languages

by Dan Wohlbruck
In the first of a two-parter, Dan looks at the C language, its roots, and its influence.

Rothman and Lester

Some days are more productive than others. Why is that? Johanna and Andy share some techniques to make every work day more productive.

Antonio on Books

Antonio’s got all the new tech books of note.

Shady Illuminations

by John Shade
John returns from vacation with some thoughts on why some things are the way they are.

…and more.

OCTOBER

PureScript. Ruby. COBOL?

Generative Testing With PureScript

by Phil Freeman
PureScript is a simple functional language that compiles to JavaScript. Let its creator take you on a tour.

Ruby Performance Tuning

by Alexander Dymo
Speed up your Ruby code drastically with these techniques.

The Right Thing in the Wrong Order

by Brian Marick
The best programmers are continually learning how to improve in their craft — and often generously share what they learn.

The History of Programming Languages

by Dan Wohlbruck
The latest installment in the series.

Rothman and Lester

Career advice by Johanna Rothman and Andy Lester.

Antonio on Books

Antonio’s got all the new tech books of note.

Shady Illuminations

by John Shade
Sitting in for John, Mike offers some more off-kilter history.

…and more.

SEPTEMBER

It’s a value proposition.

When TDD Doesn’t Matter

by Kent Beck
Kent really doesn’t care if you “do” TDD—so long as you know the consequences.

First-Class Functions in Swift

by Daniel Steinberg
Daniel offers a gentle introduction to Apple’s new iOS and OS X development language, Swift. In the process he dips into first-class functions and functional programming.

Giving Back

by David Bock
In this latest in our series on teaching kids to code, David shares his experience and invites you to join in.

The History of Programming Languages

by Dan Wohlbruck
The latest installment in the series.

Rothman and Lester

Career advice by Johanna Rothman and Andy Lester.

Guest Essay

Ron Jeffries shares lessons learned.

Antonio on Books

Antonio’s got all the new tech books of note.

Shady Illuminations

by John Shade
Sitting in for John, Mike offers some warped history.

…and more.

AUGUST

More Swift coverage, plus computer history and career tips.

Protocols in Swift, Ruby, and Elixir

by José Valim
The creator of the Elixir language compares it to Apple’s new language.

Writing a Vim Syntax File for Swift

by Ben Klein
Making Apple’s new language Vim-friendly.

Two Guys in a Garage

by Michael Swaine and Paul Freiberger
Three stories of startups that only needed a few hundred dollars to get off the ground.

The History of Programming Languages

by Dan Wohlbruck
The latest installment in the series.

Rothman and Lester

Career advice by Johanna Rothman and Andy Lester.

Guest Essay

Kent Beck shares lessons learned.

Antonio on Books

Antonio’s got all the new tech books of note.

Shady Illuminations

by John Shade
John shares his thoughts on Satya Nadella.

…and more.

JULY

July’s our Swift issue, focusing on Apple’s new language for app development.

Swift: Didn’t See That Coming

by Mark Chu-Carroll
Apple has shaken up iOS and OS X development with a new language. To really understand Swift, we need to see where it came from.

Swift from a TDD Perspective

by Ron Jeffries
Apple’s new language features a nifty way to test out ideas — but does it undermine test-driven programming practices?

Swift: What You Need to Know

by Mark Chu-Carroll
Mark lays out the key object-oriented and functional features of the language.

Functional Thinking in Swift

by Tony Hillerson
Tony uses Swift to explore the functional approach to programming.

Swift Isn’t Perfect

by Mark Chu-Carroll
At present, Swift is buggy, is missing key features, and reflects some strange choices. Still…

Some Inconvenient Truths About Software

by Jonathan Rasmusson
You will always have more to do than time and money will allow.

The First Stored Program

by Dan Wohlbruck
The EDVAC used four bits to represent an instruction’s OP code, so its machine language could have no more than sixteen instructions. John von Neumann decided he only needed twelve.

Rothman and Lester

Career advice by Johanna Rothman and Andy Lester.

Guest Essay

Tom Mahon warns that we are becoming the tools of our tools.

Antonio on Books

Antonio’s got all the new tech books of note.

Shady Illuminations

by John Shade
John shares his thoughts on Elon Musk.

…and more.

JUNE

Why Johnny Can’t Be Agile

by Andy Hunt
Why adopting agile methods might be harder than you think.

Programming Elixir

by Dave Thomas
Elixir is a Ruby-like language on the Erlang VM.

Building Your Battlestation

by Mike Riley
Your Battlestation is your PC work/play space, designed and built by you, from GPU selection to LED placement.

Chad Fowler on Ruby

interviewed by Michael Swaine
A legend in the Ruby community reflects on the early days of Ruby and speculates on its future.

Responsive Design

by Kent Beck
Kent reflects on his years designing software and concludes that we need a new approach.

Estimation is Evil

by Ron Jeffries
What you don’t know can hurt you, especially when you convince yourself that you do know it.

Functional Thinking For The Imperative Mind

by Michael Bevilacqua-Linn
How does functional thinking differ from the imperative kind?

Black Friday

by Michael Nygard
A blow-by-blow account of riding the perfect webstore support storm.

Punk Rock Languages

by Chris Adamson
In an era of virtual machines and managed environments, C is the original Punk Rock Language.

Programming and the ENIAC

by Dan Wohlbruck
Dan brings his history of programming languages up to the ENIAC era.

Rothman and Lester

Career advice by Johanna Rothman and Andy Lester.

Antonio on Books

All the new tech books of note.

Shady Illuminations

by John Shade
John surveys the leading examples of software development manifestos and makes some suggestions.

…and more.

MAY

On Tap

The editorial, by Michael Swaine.
What’s in the issue.

Choice Bits

A month recaptured in news bits and tweets.

Rothman and Lester

Career advice by Johanna Rothman and Andy Lester.

Process Agnosticism

by Allen Holub
Agile adoption is proceeding more slowly abroad. Maybe they’ll do it better.

The Agile Mindset

by Jonathan Rasmusson
The Agile Samurai reflects on the agile way of thinking.

The Next Seven Coaching Patterns

by Portia Tung
Proven patterns for improving your coaching.

The Anti-Cosby Approach to Teaching Kids Programming

by Chris Strom
Bill Cosby was wrong.

Programming Unit Record Machines

by Dan Wohlbruck
A data processing project that got completely out of control, and the man who saved the day.

Pragmatic Bookstuff

Want to meet one of the Pragmatic Bookshelf authors face-to-face? Here’s where they’ll be in the coming months. Also, find out what are the top-selling Pragmatic Bookshelf books and what new books are coming out.

Antonio on Books

All the new tech books of note.

Shady Illuminations

by John Shade
John has some advice for the creators of wearable technology.

APRIL

On Tap

The editorial, by Michael Swaine.
What’s in the issue.

Choice Bits

A month recaptured in news bits and tweets.

Rothman and Lester

Career advice by Johanna Rothman and Andy Lester
If you write as a part of your profession, you should write professionally. And that probably doesn’t mean what you think it means.

The New Feudalism and the Common Good

by Tom Mahon
The tools we create should serve the deepest needs of human beings. Can it really be that our deepest needs are war and toys?

The Selfish Teacher

by Michael Swaine
How teaching a kid to code could be a wonderful thing to do—for yourself.

Sound Design in Practice

by Tony Hillerson

Tony relies on one of the universal verities in this hands-on demonstration of how to design the perfect sounds for your app:
Everything’s better with bacon.

The Elegance of C

by David Lowe
It is rare that we see C code that so fully embodies the true nature of its language. And as a bonus, this code proves that even a very short program can embody great depths and subtlety.

XP is the Mac of Agile

by Jonathan Rasmusson
In the 2000s, XP changed software development. But its core principles are even more important today.

The Discovery of Programming Languages

by Dan Wohlbruck
Back then it was just programming.

Pragmatic Bookstuff

Want to meet one of the Pragmatic Bookshelf authors face-to-face? Here’s where they’ll be in the coming months. Also, find out what are the top-selling Pragmatic Bookshelf books and what new books are coming out.

Antonio on Books

This month Antonio expands his coverage of new tech books of note.

Shady Illuminations

by John Shade
John reveals the secret behind bitcoin. Also dogecoin.

MARCH

On Tap

The editorial, by Michael Swaine.
What’s in the issue.

Choice Bits

A month recaptured in tweets.

Constraints and Freedom

by Jimmy Thrasher
It was Igor Stravinsky who said, “The more constraints one imposes, the more one frees one’s self of the chains that shackle the spirit.” The same insight also applies when teaching kids to program.

Rothman and Lester

Career advice by Johanna Rothman and Andy Lester
Job transitions, whether within the same company or to a new company, are fraught with peril.

Sound Design Principles

by Tony Hillerson
Your app probably doesn’t need sound. Not really. And that’s exactly why you should approach sound from a design sensibility.

Coding Unplugged

by Fahmida Y. Rashid
Most child-oriented programming initiatives target kids in the 9–16–year-old range. But their kids were just five and eight. They needed to get creative.

Wrapping Things Up

by Michael Bevilacqua-Linn
Michael wraps up his series on the Clojure language, and to his credit, manages to avoid lame references to “getting closure.” Your editor, not so much.

Poverty on Parade

by Michael Swaine
Your editor reprises an homage to Bob & Ray and waxes nostalgic over the dot-com crash.

Pragmatic Bookstuff

Want to meet one of the Pragmatic Bookshelf authors face-to-face? Here’s where they’ll be in the coming months. Also, find out what are the top-selling Pragmatic Bookshelf books and what new books are coming out.

Antonio on Books

All the new tech books of note.

Shady Illuminations

by John Shade
John reveals his true feelings about the Valentine issue of Wired magazine.

Rear Window

Jim Weirich, 1956-2014

FEBRUARY

On Tap

The editorial, by Michael Swaine.
Teaching kids to code, getting Clojure, web-based intrusion prevention, Core Data, and more.

Choice Bits

A month recaptured in tweets.

Mac & Me

by Michael Swaine
Michael reflects on 30 years of the Mac.

Rothman and Lester

Career advice by Johanna Rothman and Andy Lester
Practical advice for managing your manager.

A Closer Look At Clojure Sequences

by Michael Bevilacqua-Linn
Clojure has come a long way from its origins in Lisp, but it manages to address a rich collection of data structures with a common Lisplike interface.

Web-Based Intrusion Prevention with Repsheet

by Aaron Bedra
Your web app is under attack. What are you doing about it?

Core Data As Data Structure Service

by Joshua Smith
Core Data makes all the hard parts go away.

Lego League: Lessons Learned

by Seb Rose
Our series on teaching kids to code continues with lessons learned from coaching and judging a coding competition.

Pragmatic Bookstuff

Want to meet one of the Pragmatic Bookshelf authors face-to-face? Here’s where they’ll be in the coming months. Also, find out what are the top-selling Pragmatic Bookshelf books and what new books are coming out.

Antonio on Books

All the new tech books of note.

Shady Illuminations

by John Shade
John shares a parable.

Rear Window

Looking back at the Mac.

JANUARY

On Tap

The editorial, by Michael Swaine.
Teaching kids to code, getting Clojure, rethinking retrospectives, and more.

Choice Bits

A month recaptured in tweets and news bits.

Teaching Kids to Code

A guest essay by David Bock
David reflects on a week teaching kids to code, and asks why we can’t make every week Computer Science Education Week.

Rothman and Lester

Career advice by Johanna Rothman and Andy Lester
How to land that dream job.

Automating Android for Your Listening Pleasure

by Mike Riley
Mike teaches his Android to walk and chew gum at the same time.

Clojure and EDN

by Michael Bevilacqua-Linn
Deep diving in the Clojure language.

Leveraging Retrospectives

by Jeff Cohen
Retrospectives are not just for teams.

The Roots of Revolution

by Michael Swaine and Paul Freiberger
An excerpt from the upcoming Fire in the Valley 3rd edition.

Pragmatic Bookstuff

Want to meet one of the Pragmatic Bookshelf authors face-to-face? Here’s where they’ll be in the coming months. Also, find out what are the top-selling Pragmatic Bookshelf books and what new books are coming out.

Antonio on Books

All the new tech books of note.

Shady Illuminations

by John Shade
John solves the Bitcoin and global warming problems with a trip to Neptune.

Rear Window

Toasting those with glasses: an appreciation of hardware nerds.

DECEMBER

On Tap

The editorial, by Michael Swaine.
This issue has a Clojure theme, but there’s lots more in this final offering for 2013.

Choice Bits

A month recaptured in tweets and news bits.

HealthCare.Gov

A guest essay by Robert “Uncle Bob” Martin
Uncle Bob names the culprit for the botched rollout of the government healthcare site: it’s you.

Rothman and Lester

Career advice by Johanna Rothman and Andy Lester
Want a raise? A new chair? Here’s how to get it.

Exploring the Java Virtual Machine Version of Clojure

by Michael Bevilacqua-Linn
Michael takes you on a whirlwind tour of Clojure’s Java interop.

Tracking Down Culprit Code in Clojure

by Dmitri Sotnikov
Learning Clojure? Here’s a project that will give you hands-on experience with writing Clojure code.
(Here’s the sample code for the Metaballs examples in Dmitri’s article.)

Making Music with Clojure

by Sam Aaron
Admit it: your real mission in life is to modify code in real time and have it projected on screens in a nightclub. Welcome to the wild world of Livecoding.

The Basics

by Michael Swaine and Paul Freiberger
An excerpt from the upcoming Fire in the Valley 3rd edition.

Pragmatic Bookstuff

Want to meet one of the Pragmatic Bookshelf authors face-to-face? Here’s where they’ll be in the coming months. Also, find out what are the top-selling Pragmatic Bookshelf books and what new books are coming out.

Antonio on Books

All the new tech books of note.

Shady Illuminations

by John Shade
John casts a jaundiced eye at the latest announcements from Wolfram Research and IBM.

Rear Window

The first programmer turns 198 this month.

NOVEMBER

On Tap

The editorial by Michael Swaine.

Choice Bits

Flotsam on the Twittertide, tech books of note, and other goodies we snared in our net.

Rothman & Lester

A dialog on career advice by Johanna Rothman and Andy Lester
Should I stay or should I go?

Namespaces in Clojure

An ongoing series on the Clojure language by Michael Bevilacqua-Linn
In this installment, Michael gives you “just enough about namespaces to get you going.”

Rediscovering Awk

by Derrick Schneider
A tedious task sends Derrick digging through the musty man pages of an archaic language, where he unearths some gems.

Good and Bad Technical Debt

by Henrik Kniberg
Sometimes technical debt is good. The trick is knowing how much and when.

Seven Coaching Patterns

by Portia Tung
Talk less, listen more, and other habits to cultivate.

Nostalgia for the Future

by Michael Swaine and Paul Freiberger
Homebrew and Proc Tech: an excerpt from the upcoming Fire in the Valley 3rd edition.

Pragmatic Bookstuff

Want to meet one of the Pragmatic Bookshelf authors face-to-face? Here’s where they’ll be in the coming months. Also, find out what are the top-selling Pragmatic Bookshelf books and what new books are coming out.

Shady Illuminations

by John Shade
John reflects on the Post-Post-PC Era, Jony Ive’s fingerprints, and just-in-time deconstructionist iconography.

Rear Window

The first computer mouse, invented by Doug Engelbart at SRI in 1964, was carved from a block of wood.

get it

OCTOBER

On Tap

The editorial by Michael Swaine.

Choice Bits

This month Choice Bits expands to include Antonio on Books.

Rothman & Lester

A dialog on career advice by Johanna Rothman and Andy Lester
Johanna and Andy share tips on career development and becoming a T-shaped person.

Clojure and Polymorphism

An ongoing series on the Clojure language by Michael Bevilacqua-Linn
Java and Clojure have different approaches to polymorphism. Understanding how Clojure uses polymorphism is critical to Clojure mastery.

The Luminus Framework

by Dmitri Sotnikov
How to build a web application quickly using Clojure and the Luminus micro-framework.

Game Plan

A challenge from Chris Crawford
A legend in computer game design offers a project that could make games better.

Mobile Applications vs. Web Pages

by Brian Tarbox
Are there service for which you have both the mobile app and a link to the web site? Is there a hint there that something is not right?

Creating the Apple ][

by Michael Swaine and Paul Freiberger
Jobs in tears, Woz playing pranks, and the ad in Playboy: the crazy days leading up to the release of the Apple ][.

Shady Illuminations

by John Shade
John gives career advice, which you are well advised to ignore.

Rear Window

Wayne Green and the birth of Byte Magazine.

get it

SEPTEMBER

On Tap

The editorial by Michael Swaine.

Choice Bits

We follow Twitter so you don’t have to.

Rothman & Lester

A dialog on career advice by Johanna Rothman and Andy Lester
The key to a successful interview is preparation. Johanna and Andy discuss how to walk in the room prepared to nail it.

Playing with the Play Framework

by Nilanjan Raychaudhuri
Time to play? Get the scoop on Play Framework, which has been getting a lot of attention for how easy it makes it to build web applications with Java and Scala.

Concurrent Programming in Clojure

An ongoing series on the Clojure language by Michael Bevilacqua-Linn
Michael continues his exploration of Clojure with a look at its advantages for concurrent programming.

The Automated Tester

by Jonathan Rasmussen
Don’t let yourself be limited by yesterday’s job definitions.

Hadoop

by Jesse Anderson
What you don’t know about Hadoop, and should.

Puzzle

by Michael Swaine
A short session in mental calisthenics.

Calendar

Want to meet one of the Pragmatic Bookshelf authors face-to-face? Here’s where they’ll be in the coming months.

Bookshelf

What’s new and what’s hot from the Pragmatic Bookshelf.

Guest Column

by James Iry
John Shade is on vacation and James Iry is filling in.

Rear Window

Ted Nelson’s Computer Lib, the inimitable book that served as the manifesto for a revolution.

get it

AUGUST

On Tap

The editorial by Michael Swaine.

Choice Bits

We follow Twitter so you don’t have to.

Rothman & Lester

A dialog on career advice by Johanna Rothman and Andy Lester
Johanna and Andy talk about how to articulate your own value in a résumé.

Programming Elixir

by Dave Thomas
Elixir is a modern, functional programming language designed for high availability and concurrency. It has Ruby-like syntax married to the power and reliability of the Erlang VM. If you wanted to get into functional programming but were put off by the academic feel, now’s the time to jump in.

Identity, Value, and State in Clojure

An ongoing series on the Clojure language by Michael Bevilacqua-Linn
Michael looks at Clojure’s novel philosophy on identity, value, and state.

Finding the Joy in Legacy Code

by Jeff Foster
The people who wrote that code knew more than you do about the problem they were solving.

Big Problems

by Jesse Anderson
A cautionary tale.

3D Graphics with SceneKit

by David Rönnqvist
The ramp from 2D to 3D is steep, but a really good framework helps a lot.

Puzzle

by Michael Swaine
A short session in mental calisthenics.

Calendar

Want to meet one of the Pragmatic Bookshelf authors face-to-face? Here’s where they’ll be in the coming months.

Bookshelf

What’s new and what’s hot from the Pragmatic Bookshelf.

Shady Illuminations

by John Shade
John embraces the metaphor of the software developer as a downhill skier, and encourages developers to embrace the trees they’ll encounter on their downhill run.

Rear Window

What Ed Roberts did after creating the personal computer.

get it