Seven Languages in Seven Weeks: A Pragmatic Guide to Lear... und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr


oder
Loggen Sie sich ein, um 1-Click® einzuschalten.
Jetzt eintauschen
und EUR 6,25 Gutschein erhalten
Eintausch
Alle Angebote
Möchten Sie verkaufen? Hier verkaufen
Der Artikel ist in folgender Variante leider nicht verfügbar
Keine Abbildung vorhanden für
Farbe:
Keine Abbildung vorhanden

 
Beginnen Sie mit dem Lesen von Seven Languages in Seven Weeks auf Ihrem Kindle in weniger als einer Minute.

Sie haben keinen Kindle? Hier kaufen oder eine gratis Kindle Lese-App herunterladen.

Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages (Pragmatic Programmers) [Englisch] [Taschenbuch]

Bruce A. Tate
4.7 von 5 Sternen  Alle Rezensionen anzeigen (3 Kundenrezensionen)
Preis: EUR 22,95 kostenlose Lieferung Siehe Details.
  Alle Preisangaben inkl. MwSt.
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Nur noch 2 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Lieferung bis Donnerstag, 23. Oktober: Wählen Sie an der Kasse Morning-Express. Siehe Details.

Weitere Ausgaben

Amazon-Preis Neu ab Gebraucht ab
Kindle Edition EUR 17,13  
Taschenbuch EUR 22,95  

Kurzbeschreibung

3. Dezember 2010 Pragmatic Programmers
Ruby, Io, Prolog, Scala, Erlang, Clojure, Haskell. With Seven Languages in Seven Weeks, by Bruce A. Tate, you'll go beyond the syntax-and beyond the 20-minute tutorial you'll find someplace online. This book has an audacious goal: to present a meaningful exploration of seven languages within a single book. Rather than serve as a complete reference or installation guide, Seven Languages hits what's essential and unique about each language. Moreover, this approach will help teach you how to grok new languages. For each language, you'll solve a nontrivial problem, using techniques that show off the language's most important features. As the book proceeds, you'll discover the strengths and weaknesses of the languages, while dissecting the process of learning languages quickly--for example, finding the typing and programming models, decision structures, and how you interact with them. Among this group of seven, you'll explore the most critical programming models of our time. Learn the dynamic typing that makes Ruby, Python, and Perl so flexible and compelling. Understand the underlying prototype system that's at the heart of JavaScript. See how pattern matching in Prolog shaped the development of Scala and Erlang. Discover how pure functional programming in Haskell is different from the Lisp family of languages, including Clojure. Explore the concurrency techniques that are quickly becoming the backbone of a new generation of Internet applications. Find out how to use Erlang's let-it-crash philosophy for building fault-tolerant systems. Understand the actor model that drives concurrency design in Io and Scala. Learn how Clojure uses versioning to solve some of the most difficult concurrency problems. It's all here, all in one place. Use the concepts from one language to find creative solutions in another-or discover a language that may become one of your favorites.

Wird oft zusammen gekauft

Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages (Pragmatic Programmers) + Seven Databases in Seven Weeks: A Guide to Modern Databases and the NoSQL Movement + Seven Concurrency Models in Seven Weeks: When Threads Unravel (The Pragmatic Programmers)
Preis für alle drei: EUR 69,85

Die ausgewählten Artikel zusammen kaufen

Kunden, die diesen Artikel gekauft haben, kauften auch


Produktinformation

  • Taschenbuch: 328 Seiten
  • Verlag: O'Reilly Vlg. Gmbh & Co.; Auflage: 1 (3. Dezember 2010)
  • Sprache: Englisch
  • ISBN-10: 193435659X
  • ISBN-13: 978-1934356593
  • Größe und/oder Gewicht: 23,9 x 18,3 x 3 cm
  • Durchschnittliche Kundenbewertung: 4.7 von 5 Sternen  Alle Rezensionen anzeigen (3 Kundenrezensionen)
  • Amazon Bestseller-Rang: Nr. 7.165 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)

Mehr über den Autor

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

Produktbeschreibungen

Pressestimmen

""I have been programming for 25 years in a variety of hardware and software languages. After reading Seven Languages in Seven Weeks, I am starting to understand how to evaluate languages for their objective strengths and weaknesses. More importantly, I feel as if I could pick one of them to actually get some work done.""--Chris Kappler, Senior scientist Raytheon, BBN Technologies""I spent most of my time as a computer sciences student saying I didn't want to be a software developer and then became one anyway. Seven Languages in Seven Weeks expanded my way of thinking about problems and reminded me what I love about programming.""--Travis Kaspar, Software engineer, Northrop Grumman""Do you want seven kick starts into learning your "language of the year"? Do you want your thinking challenged about programming in general? Look no further than this book. I personally was taken back in time to my undergraduate computer science days, coasting through my programming languages survey course. The difference is that Bruce won't let you coast through this course! This isn't a leisurely read--you'll have to work this book. I believe you'll find it both mindblowing and intensely practical at the same time.""--Matt Stine Group leader, Research Application Development, St. Jude Children's Research Hospital

Über den Autor und weitere Mitwirkende

Bruce A. Tate is a kayaker, mountain biker, and father of two. In his spare time, he is an independent consultant in Austin, Texas. In 2001, he founded J2Life, LLC, a consulting firm that specializes in Java persistence frameworks and lightweight development methods. His customers have included FedEx, Great West Life, TheServerSide, and BEA. He speaks at conferences and Java user's groups around the nation. Before striking out on his own, Bruce spent 13 years at IBM working on database technologies, object-oriented infrastructure, and Java. He was recruited away from IBM to help start the client services practice in an Austin startup called Pervado Systems. He later served a brief stint as CTO of IronGrid, which built nimble Java performance tools. Bruce is the author of four books, including the bestselling "Bitter Java", and the recently released Better, Faster, Lighter Java, from O'Reilly. First rule of kayak: When in doubt, paddle like Hell.

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


Kundenrezensionen

3 Sterne
0
2 Sterne
0
1 Sterne
0
4.7 von 5 Sternen
4.7 von 5 Sternen
Die hilfreichsten Kundenrezensionen
30 von 31 Kunden fanden die folgende Rezension hilfreich
Format:Taschenbuch|Verifizierter Kauf
Ich habe das Buch, anders als der Autor vorschlägt, nicht gelesen und währenddessen die Programmierbeispiele praktisch ausprobiert (außer bei der ersten beschriebenen Sprache Ruby), sondern direkt runtergelesen, weil ich lediglich einen tieferen Einstieg in (aktuelle) Entwicklungen der verschiedenen Programmierparadigmen (Objektorientierung, funktional, logisch, Prototype) bekommen wollte, ohne diese praktisch anzuwenden. Und dafür ist das Buch wirklich super! Bruce Tate zeigt anhand von sinnvollen Praxisbeispielen mit sehr vielen Quelltextauszügen die Vor- und Nachteile der einzelnen Sprachen (Ruby, Io, Prolog, Scala, Erlang, Clojure und Haskell) auf und geht insbesondere auf die jeweiligen Vorzüge ein, die das Programmieren einfacher machen ("syntactic sugar"). Für alle, die die Sprachen auch in der Praxis ausprobieren wollen, liefert Tate nach jedem Kapitel Online-Quellen und Tipps für interessante Miniprojekte.

Dabei folgt er einem sehr sinnvollen Aufbau. Bei den ersten behandelten Sprachen werden allgemeingültige Konzepte von Programmiersprachen eingeführt und anhand von Beispielen erklärt (z.B. Pattern Matching, Rekursion, Closures, Futures) und bei den Sprachen im hinteren Teil des Buches wieder aufgegriffen und vertieft. Dabei streift Tate wirklich viele aktuelle Entwicklungen insbesondere aus dem Bereich der funktionalen Sprachen: 5 der 7 Sprachen sind entweder komplett oder in Teilen funktional. Ich kannte bislang von den vorgestellten Sprachen lediglich Prolog, sodass mir das Kapitel hierzu als kleine Auffrischung meiner Kenntnisse diente. Ich war überrascht, wie viele (hilfreiche) Konzepte es aus Prolog inzwischen in andere Programmiersprachen geschafft haben.
Lesen Sie weiter... ›
War diese Rezension für Sie hilfreich?
13 von 14 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Ein Muss für Programmiere 24. Juni 2011
Format:Taschenbuch|Verifizierter Kauf
Ich mach's kurz: Wer sich für Programmiersprachen und Programmierparadigmen interessiert und nicht schon mindestens drei der im Buch vorgestellten Sprachen kann, der sollte dieses Buch kaufen. Unbedingt.

Sehr gut geschrieben und ein frischer didaktischer Ansatz. Allerdings sollte man schon gut Englisch können, sonst könnte es Verständnisprobleme geben.
War diese Rezension für Sie hilfreich?
5 von 6 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Sehr gut, um über den Tellerrand zu blicken 20. Februar 2012
Format:Taschenbuch
Sehr unterhaltsames und lehrreiches Buch. Habe es im Urlaub komplett ohne Computer durhgearbeitet, was man lt. Autor eigentlich nicht tun sollte. Es war trotzdem sehr hilfreich, tiefer in sein tägliches Arbeitsgerät Einblicke zu erhalten oder neue Programmierparadigmen kennenzulernen.

Ein Stern minus für das ständige Wiederkäuen einfachster Datenstrukturen. Wahrscheinlich lässt sich das aber auch einfach nicht umgehen, bei dieser Art von Buch.
War diese Rezension für Sie hilfreich?
Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)
Amazon.com: 4.3 von 5 Sternen  41 Rezensionen
185 von 189 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Much (perhaps over) anticipated 9. November 2010
Von MedIT - Veröffentlicht auf Amazon.com
Format:Taschenbuch|Verifizierter Kauf
Background: I stumbled across the author's blog post announcing his intention to write the book while looking for materials comparing language paradigms instead of particular languages (object-oriented, logical, functional, prototype, etc). The as yet unwritten book sounded like exactly what I was after (thus my enthusiastic anticipation). I purchased an electronic copy of this book from the Prag Press beta program about six months ago and began reading the chapters as they were completed and released. My paper copy just arrived from Amazon today. Thus I can comment on the whole content of the book and the physical object.

Languages: While the languages covered (Ruby, Io, Prolog, Scala, Erlang, Clojure, Haskell) are excitingly (painfully?) trendy the list is not without merit. In the introduction the author explains that he arrived at the list by asking readers and edited from there: swapping Io for JavaScript and excluding Python thereby making room for Prolog. One could debate the choice of Io over JavaScript (particularly in a post Node.js / Common.js world) and make a case for including Smalltalk as the canonical OO language over Ruby; however, the chosen languages each bring something to the book and represent a number of interesting paradigms.

Chapters: Each language has its own chapter. Each chapter has five sections:
- an introduction to the language covering topics like it's history, place in the modern language landscape, paradigm, etc
- 'Day 1'
- 'Day 2'
- 'Day 3'
- and a conclusion with a few parting words / 'the moral of the story is...'.
The boundaries between days are not particularly meaningful but roughly build from "here's the syntax" to "here's an interesting thing you can do with this paradigm". By Day 3 each chapter has moved beyond trivial "hello world" examples; not surprisingly then, the pace of progress is brisk and the details of how to get up and running with each language are largely left to the reader.
Each language chapter includes an interview with a user/creator of the language (Matz, Steve Dekorte, Brian Tarbox, Martin Odersky, Joe Armstrong, Rich Hickey, Philip Wadler / Simon Peyton-Jones). These were an unexpected addition and quite worth reading. In fact, I wish the interviews had been longer and gone into more technical detail.
In addition to the seven language chapters there is an introductory chapter that has the sort of information normally found in the pre-page-numbering introduction to a book (explanation of the book's contents, intended audience etc) and an excellent final wrap-up chapter (more on it later).

Length: I easily completed each language chapter in a weekend. The first and last chapters are very quick reads. Seven weeks should be more than enough time to work through the book.

Subjective annoyances:
- The quality of the physical book (not great) will be familiar to regular Prag Programmer shoppers. It is not up to O'Reilly standards (it's more like an Apress book). Although the typesetting is easy to read the top and bottom margins are unpleasantly tight. The outside margin leaves room for notes which I like, but the book is awkwardly square. For $22 what does one expect?
- Each chapter attempts creativity with a supposedly allegorical popular culture reference threaded through it (ex: Io = Ferris Bueller). I found these more distracting than informative. I'd include naming the chapter sections "day n" as similarly failed attempts and wish that instead attempting wit (ex Io Day1: An Excellent Driver) they had substantive names. Obviously this is totally personal opinion, you might like it.

Outright Disappointment: I wish that the individual chapters went into significantly more depth comparing the motivations for and consequences of each language design. While the key features of each language are demonstrated with annotated code samples and explanatory text little is offered in the way of discussion comparing across language. For example the Scala chapter (selected at random) is on pages 121-166 in the index under "Scala" the only references outside its own chapter are found on pages 302, 303, 305-306, and 308 (all in the final wrap-up chapter). I view this as a real missed opportunity given the books unique approach/content. The final wrap-up chapter seems to be the only place with this sort of cross-language discussion and as a result it is both excellent and much too short.

Conclusion: An interesting book that I enjoyed reading and expect to return to in the future. The physical book is of so-so quality and as such the electronic book may be the right product for you to buy. The missed opportunity (and loss star) are for a disappointing failure to draw cross-language comparisons within the text of each chapter.

----------
Update: [...]is a 45 min talk on the book / topics in the book.
58 von 66 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen Too shallow to be interesting 26. Juni 2011
Von Brian L. - Veröffentlicht auf Amazon.com
Format:Taschenbuch
I was very disappointed in this book. I could have attain a similar level of depth with fewer unnecessary film-based analogies by reading each langauges' wikipedia page.

The author focuses heavily on syntax, program structure, and how common things are represented in each language, what the REPL, looks like in each case, etc. There many belabored explanations of well-understood language-agnostic concepts like prototypes, actors, futures, recursion, laziness, and immutability. Zero of these languages are interesting because of how lists work yet the book laboriously visits this example over and over. Similarly, only one or two of the languages has truly interesting things to say about concurrency, but he discusses concurrency over and over.

Each of these languages has made important contributions to the field of programming language design and culture. This is where the time should be spent--not developing a familiarity with basics like syntax and list operations. If I want to know what the code is going to look like visually, I can use wikipedia.

For instance, a core idea behind prolog is unification. The author gives lots of examples of prolog code, but fails to explain at any level of detail the theoretical basis for unification or how it works. I don't have a prolog background, and when I sat down to read the chapter, I hoped to come away with a basic working understanding of the concepts. All I ended up with is some ideas of how prolog is used and what it feels like at the surface of its syntax/semantics.

One of the most interesting things in Io is the combination of an unusually transparent message-passing discipline with a mutable syntax tree. In Io, you can build messages that serve as macros--mutating their call-site at the first invocation in order to generate code, accomplish call-by-name semantics, or do any number of other interesting things. These patterns exist throughout the standard library, and at least when I was participating in the Io community more actively, were one of the most frequent topics of discussion. This stuff is really, really cool, and the author didn't do it justice, instead spending time explaining basic ideas like actors and prototypes as if Io is extremely unique for having them.

Ruby is actually fairly boring as a programming language in and of itself. It's largely a reboot of smalltalk semantics into the clothing of a scripting language. Hardly a great innovation. However, the ruby community has developed an awesome culture--a culture that is certainly informed by ruby itself, but is not at all inherent to it. Even though ruby stopped being an everyday language for me several years ago, the lessons I learned from its culture continue to influence my work in other languages. The author should have spent time discussing this culture and how culture contributes to ruby's success instead of belaboring the basics of syntax or explaining ruby's unimpressive module system or its approach to concurrency.

Instead of focusing on the beauty in these systems, the author opted to do something far more boring--write a collection of shallow tutorials.

Finally, I was disappointed that the author neglected to include any languages suitable for high-performance computing or systems programming. This might have included Go or D.

I'm not sure who this book is good for. I didn't get much out of it, and despite my vast appreciation for the contributions of these languages, I felt that the book didn't do them justice, instead opting to focus on basics and trivialities. My advice is to skip it. Maybe someone will do this concept well someday, but this book isn't it.
63 von 73 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Not interested in the merchandise 17. März 2011
Von Dmitry Dvoinikov - Veröffentlicht auf Amazon.com
Format:Taschenbuch
The idea is good - have a brief overview of several programming languages that gather most curiosity in the community. The languages that made it to the book were chosen by the people the author asked beforehand.

Each language is given 3 days worth of chapters. First day is for a = b, second is for [a] = [b] and the third is for "real stuff". About two thirds of the book are therefore dedicated to simple variable assignments, number literals, containers (lists mostly), and control structures such as if's.

And herein lies the problem - although great to know that in language X assignment goes like

console> plz let a be 1
a nowz 1!!!oneone
console>

but what does it tell about the language ?

---QUOTE---
I'm confident that this material will capture the spirit of each programming language pretty well...
---/QUOTE---

I don't think it happened. It would be possible if the author had spent years working in each one. This is not the case, the author had learned the languages himself, took a bite and now explains the fullness and richness of taste. There is no trick here, the author is not pretending he is an expert in everything. All this is clearly admitted upfront. On the other hand a lot is required from the reader too. You are expected to give each individual language a try. Otherwise

---QUOTE---
If you simply read this book, you'll experience the flavour of the syntax and no more.
---/QUOTE---

Exactly what happened to me. None of the seven languages made me curious because of this book. I was curious about erlang before and I still am. I saw something beautiful behind haskell and I still do. The languages I haven't seen before, I'm as unsure about now as I was before.

The book doesn't answer the real questions. You will not *learn* any of the languages. It is at most a bait for a curious programmer having one of his "oh ! interesting !" moments.

I'd recommend this book for someone who is dying to get his hands dirty in just any language but is unsure which one to pick.
23 von 29 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Seventh heaven for language lovers 23. November 2010
Von MrC - Veröffentlicht auf Amazon.com
Format:Taschenbuch
Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages

What first attracted me to this book is its coverage of several languages that I know little or nothing about. For reasons mostly due to chance, I've been exposed to only a handful of well-known programming languages, during my professional career. Recently, I've been quite intrigued by Erlang's concurrency model and robustness even though there is no place for it in my day-day tasks. Having the opportunity to read about Erlang being evaluated against other languages was just what I wanted. So, I took the red pill and found out just how deep the rabbit hole goes.

"Seven Languages in Seven Weeks" covers Ruby, Io, Prolog, Scala, Erlang, Clojure and Haskell. These languages were chosen as of the result of a survey. When the data was tallied, 8 potential candidates remained. Given that there are so many languages around I'm quite surprised that the initial list was so small. That speaks a lot of the languages that ended up in the book.

First off, I like this book a lot. It starts off with a brief, one-paragraph introduction on each of the languages. There's just enough information here to let you know what to expect in each of the chapters. This book follows a pragmatic consistency from beginning to end.

The structure of each chapter is logical and concise which makes it easy for the reader to compare and contrast elements of each language. I also like the history and language development sections as well as interviews with the language developers. Each chapter concludes with a nice "Wrap Up" segment which summarizes key areas of each language, such as performance, mutability, weaknesses, strengths, readability, etc. In fact, the final chapter is a "Wrap Up" of the whole book. I don't know of a better way to conclude this book.

The size of the book is a modest 317 pages, but it delivers a plentiful and concise overview into each of the seven languages. The book is just the right size to catch the reader's interest, introduce them to language basics features and fun, without overwhelming them.

I couldn't help but wonder if there would be a follow-on title comparing and contrasting another group of languages. And if so, which languages would they be?

The introduction concludes with the following statement:

"When you're through, you will not be an expert in any of these languages,
but you will know what each uniquely has to offer"

I can't agree more.

I can't say enough good things about this book. If you've worked with many languages in this book, you probably won't be as interested in this book as I am. However, if you've had a career like mine which hasn't exposed you to more than a few languages, this book is a must-have for your collection. It may even inspire me to delve into another language, after I get my head around Erlang and FP concepts.
7 von 8 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Polishing needed -- badly! 29. Januar 2012
Von Maciej Pilichowski - Veröffentlicht auf Amazon.com
Format:Taschenbuch
I wish I could write "real gem you should read", but I can't -- after reading it from cover to cover I have to admit I wasn't able to read all text, and because of that it is more like "pile of mud with gem in it".

The biggest disappointment of this book is... the author. I bought and I intended to read a book about computer languages. Instead I got ton of "intelligent" remarks how given language syntax looks like Mary Poppins or Mr.Stock. Come on! Is this some kind of fairy tale or pure information for programmers? This fluff is not funny at all, at first I felt embarrassed, but with each such piece more it was nauseating. I don't know -- maybe the author tried very hard to be wit (the results are quite opposite) or maybe it was just easier to make the book thicker instead of spending time providing more details of the languages.

The second, very close to the above, problem is repeating to the death from boredom -- recapping ("so, we've just learned..." and there goes entire section about what was written section before, great if your readers have memory deficits) and constant remarks ("that was easy / that was hard" -- for who, I could ask, because for programmers, it was just code).

It is saddening and disappointing especially, when you realize that in the very introduction the author states "Buy This Book ...if you are a competent programmer who wants to grow.". Now, show me a competent programmer who on one hand knows Lisp, Java, C++, and on the other needs sweeteners like this one "the syntax is logical (...) just not very convenient. Agent Smith just kicked sand all over my kid nephew, and I think I heard him laugh." Really? REALLY?

For us -- programmers who are driven by pure passion -- programming is fun! We don't need Mary Poppins being Ruby (or vice versa), code is interesting by itself. All authors of computer books (except those introductory, for ~8 years old kids) should get this message into their heads. One can make vivid analogy (sequence ~ centipede) but not cracking juvenile "jokes" every second page!

The above part was objective (I hope) -- subjective complain is the goal and execution of the book. Book can teach, or book can just show. I would prefer just showing the most interesting concept of the languages, because, let's face it, if you try to learn 7 languages at the same time, I doubt you are serious, and if you try to do it only with 1, you just paid too much for the value. However, the author tries to teach by showing -- material is very shallow, and I don't think it makes any sense, especially tasks to do on your own (like finding description of the language in Wikipedia; gee, why I didn't think about it before?).

If you (mentally) take out all the dead parts, the rest is rather thin. And it is pity, because I wanted a "programmer feast".

After all this criticism, you expect probably that I will say "junk, don't buy it". No -- buy it despite this. Unfortunately (sic!) this is a good book (something like "a feast for programmers on a diet"). It will (I think) get you inspired. You will learn despite all mistakes, misleading information (author refers to similarities among languages in chapter order, not in chronological order). You will get some word from the designers of the languages (there are interviews with them in the book, although short). Most importantly you will probably get intrigued, teased. And this is the main value of this book, and also it is one of its kind (I don't know anything better than this book) -- I can say for myself, I was intrigued and excited, especially about Erlang and Clojure. Suffice to say, I already ordered book about Erlang, and I consider buying another for Clojure (I won't order one about Scala, because I already have one). But once again, the excitement is thanks to the languages features, not author's writing skills (however I see and appreciate effort of putting seven languages in single book by one, not seven, author).

If you are ready to explore new ideas, you don't live in (Java?) coffin -- this book is for you. But please don't buy it with high hopes.

I, kind of, wait for the second edition. Only (!) if author removes all the sickening-funny stuff, emphasizes unique features of the languages (Clojure macros description takes about the same place as comparisons in Ruby), and "compress" the same (like filter -- in Scala, Haskell, Clojure). It would be valuable to add Forth and Eiffel, and maybe just one chapter for languages for which their time passed -- I think about COBOL and FORTRAN here. They deserve being mentioned, for the purpose of appreciating where we are now.
But if the author will keep fooling around and pretending he is a kid with lollipop in his mouth... -- forget that I even mentioned 2nd edition. I respect other (professional) programmers and I require respect in return.

NOTE FOR POLISH READERS: my final rating is for original book. I would say that Polish edition is something like 2/5 -- because of trashy paper, lousy translation (translator doesn't know Polish too well), and translating the code (which resulted in translating even keywords from time to time!). But the value is still there, so again, even more unfortunately, but it is still worth buying... well, I'd better not say that considering the steep price (it is almost the same price as English original), but reading, yes.
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.
Kundenrezensionen suchen
Nur in den Rezensionen zu diesem Produkt suchen

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Thema:
Erster Beitrag:
Eingabe des Log-ins
 

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen
   


Ähnliche Artikel finden


Ihr Kommentar