EUR 24,60
  • Alle Preisangaben inkl. MwSt.
Nur noch 4 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon.
Geschenkverpackung verfügbar.
Build Awesome Command-Lin... ist in Ihrem Einkaufwagen hinzugefügt worden
Ihren Artikel jetzt
eintauschen und
EUR 3,98 Gutschein erhalten.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Anhören Wird wiedergegeben... Angehalten   Sie hören eine Probe der Audible-Audioausgabe.
Weitere Informationen
Dieses Bild anzeigen

Build Awesome Command-Line Applications in Ruby: Control Your Computer, Simplify Your Life (Englisch) Taschenbuch – 24. April 2012

Alle Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
"Bitte wiederholen"
EUR 24,60
EUR 17,54 EUR 18,09
11 neu ab EUR 17,54 5 gebraucht ab EUR 18,09

Dieses Buch gibt es in einer neuen Auflage:

Wird oft zusammen gekauft

Build Awesome Command-Line Applications in Ruby: Control Your Computer, Simplify Your Life + Programming Ruby 1.9 & 2.0: The Pragmatic Programmers' Guide (The Facets of Ruby) + Practical Object Oriented Design in Ruby: An Agile Primer (Addison-Wesley Professional Ruby)
Preis für alle drei: EUR 88,45

Die ausgewählten Artikel zusammen kaufen

Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.


Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr



""I know of no other Ruby book that covers the content in this useful work, especially with its eye toward making Ruby command-line applications better citizens.""--Noel Rappin, Senior engineer at Groupon and author of "Rails Test Prescriptions"""This book proves that text mode is not the just the domain of batch scripts and glue code. Beyond the extensive survey of current Ruby CLI tools, David brings an unmatched focus on user experience and testing. Every full-stack developer should learn how to build the kinds of apps covered in this book.""--Wynn Netherland, CTO, Pure Charity""David Copeland has written a guide to writing the kind of command-line apps that will make your users want to hug you...this book will show you how to take your scripts from adequate to awesome.""--Avdi Grimm, Ruby Developer and author of "Exceptional Ruby"

Über den Autor und weitere Mitwirkende

David Bryant Copeland is a veteran professional software developer who spends most of his time on the command line. He speaks frequently at national and regional Ruby conferences and built many command-line and web applications, using the command-line to productive effect.

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?

In diesem Buch (Mehr dazu)
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis
Hier reinlesen und suchen:


Es gibt noch keine Kundenrezensionen auf
5 Sterne
4 Sterne
3 Sterne
2 Sterne
1 Sterne

Die hilfreichsten Kundenrezensionen auf (beta) 5 Rezensionen
16 von 16 Kunden fanden die folgende Rezension hilfreich
The right book at the right time 15. April 2012
Von Lorin Ricker - Veröffentlicht auf
Format: Taschenbuch Verifizierter Kauf
I received my copy of "Build Awesome Command-Line Applications in Ruby" yesterday, and devoured it overnight. When I ordered it pre-release, I was expecting something a bit different from what the title suggested: I thought it'd be another book full of Ruby com-line app recipes, a cookbook from which I could crib and adapt some new apps and ideas. It actually is an application design guide, but boy what a guide.

Author David Copeland hits just the right notes with this one; succinct and to-the-point, Copeland provides a practical guide loaded with wisdom about the command line and com-line applications -- you could use his guidelines in any programming language -- with just the right amount of Ruby language specifics. This is absolutely not a Ruby primer (plenty of other good books for that); instead, it leverages Ruby's good-fit features to illuminate the best practices in writing not just passable com-line apps, but truly great ones.

The author's expertise is apparent throughout, but he's not preachy or didactic: it's all very pragmatic (no publisher pun intended), and gets down to business with little delay or diversion. His defense of the command-line, for those who still need it, is eloquent and convincing. Code samples are directly clear and prove each point. He makes good use of available libraries and gems (OptionParser and GLI), with a good appendix on other packages and approaches to com-line parsing.

As I said, this is not a "cookbook" full of "recipes"; instead, Copeland focuses on two sample applications throughout the book, evolving each to elucidate eight overall design principles (which form the core chapters of the book). The simpler app, a database backer-upper, demonstrates the "simple and focused" app, like cp or sort; the second, a light-weight to-do list manager, exemplifies a "command-suite interface" type of app, like git or gem. Along the way, the generic command-line interface syntax is taken dissected and defined. Various com-line syntax tradeoffs and design choices are clearly explained, with special focus on things like short- and long-form options (-v vs. --verbose, for instance), default values, configuration files (using YAML), and other essential considerations.

I've been learning and using Ruby for about eighteen months now, and I'd discovered early-on the ease and power of the language's OptionParser standard library module. Unfortunately, OptionParser is rather scantly documented (e.g., in the "Pickaxe Book"), and although I've used it in several of my own apps, it turns out that I've been using it naively (wrong?) all this time! Copeland's examples have set me straight and taught me much -- my code is already better and leaner for it!

My only disappointment in the book -- and it's not a deal-breaker -- is that it does not treat the issue of command-line globbing (splat-* wildcards), and how to handle this in your app, at all. I understand how a com-line splat argument is expanded into the ARGV array, but what if you want to handle globbing yourself inside the app, before expansion? Unfortunately, this book is silent on that particular issue. Maybe a follow-on book, one with even more recipes, is already warranted? I'd love to help.

But it's so strong everywhere else... I've caught only four typos, and the errata list on the book's website ([...]) is gratifyingly brief. I like this author's style, his experience and his intentions -- I think he's written a great and useful book. Strongly recommended.
8 von 8 Kunden fanden die folgende Rezension hilfreich
Predicts my every question 3. Juli 2012
Von Jeff C. - Veröffentlicht auf
Format: Taschenbuch
This was the best tech book I've read in a long time.

I write lots of utilities for work, usually in bash or rake, and was never thrilled with the user (or developer) experience. No longer! This book makes it easy to switch over to other ruby-based solutions (he goes into two in detail) and the author does a really excellent job of covering all the details that I usually struggle with for command line apps, namely structure, testing, and distribution.

The content is well-organized and as I said in the title, he does a great job of answering all the questions you should be asking. For example, I wouldn't have guessed that creating gems and your own gem server would be in a book like this, let alone RPM packaging, but those are two great solutions for distributing work around the office in a controlled fashion and the author covers them well.

Also, although I've been using Ruby for a long time, the author has opinions and techniques that have directly improved my skills.

I've since switched over to the author's two open source CLI toolkits, methadone and GLI, for all of my apps and couldn't be happier with the results for both me and my users.

If you're a developer that cranks out a lot of utilities, this book will make you better.
6 von 6 Kunden fanden die folgende Rezension hilfreich
Short, Sweet, and Easy 5. Mai 2012
Von Eric - Veröffentlicht auf
Format: Taschenbuch
In general, I find writing menial command-line apps tedious and painful in C. With this book, Ruby makes it extremely easy and elegant to accomplish the same and more. This is the perfect place to start if you just learnt Ruby, or if you want learn how to build command-line apps as a general skill. The concepts taught in this book transcend the language.

Through out the book, two command-line apps are developed, which is great for entry-mid level readers. In order to improve the book, an additional advance section towards the end of the book that develops a third more advance CLI-app would further emphasize the topics learnt from the first two apps, and in the process show off what awesome things an app can accomplish.
2 von 2 Kunden fanden die folgende Rezension hilfreich
Well Written but Too Narrow a Focus 14. September 2013
Von D. Kittrell - Veröffentlicht auf
Format: Taschenbuch Verifizierter Kauf
As other reviewers have noted, the author has done a good job of communicating Ruby (and general good practices for any language) styles and requirements for command line tools. He presents straight-forward examples of gems for handling common command line functions (parameter parsing, providing help and man pages, etc.). Where the book falls down is in using those styles and practices in the context of non-trivial tools. I was hoping to see examples of the advantages of Ruby as a means to develop CLI tools but only got a couple of "toy" tools padded out with all the bells and whistles to cover the (admittedly good) goals and principles of an idealized command line application. There's little to nothing here I can't do as easily in Python, C#, Powershell, Bash, or dozens of other programming languages. Beef up the tools being developed, show us some points where Ruby excels, and this would be an excellent title. As is, it's good for the beginning scripter not too familiar with "the Unix way" of building small, complementary, tools but offers little for more experienced developers or those wanting to see practical Ruby examples of sets of inter-working CLI-based tools that can expand, rather than limit, the user experience.
0 von 5 Kunden fanden die folgende Rezension hilfreich
Usefuly, but falls short 24. April 2013
Von Peter Burkholder - Veröffentlicht auf
Format: Taschenbuch
I'm writing the first substantial Ruby project I've tackled in a while, and I keep turning to this book hoping it'll come in handy. The explanations are clear enough, but I find it misses areas that really would be useful, like threads, and goes into far to much detail on option handling and formatting.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.