This book is a fantastic resource for anyone interested in the nitty-gritty of programming language design, implementation, and maintenance. It brilliantly showcases diverse perspectives by interviewing authors from various backgrounds and motivations, ensuring a balanced look at both industry-popular and academic languages. What's particularly impressive is how accessible it is; even without prior knowledge of language design, the discussions are easy to follow, though some familiarity will certainly enhance the enjoyment. Ultimately, I found it to be a highly entertaining read packed with practical wisdom.
This collection of interviews offered a fascinating glimpse into the diverse world of programming language designers, making the field feel much more accessible than I'd previously imagined. While a couple of the interviews felt a bit disjointed, perhaps due to a disconnect between interviewer and interviewee or a clumsy merging of separate conversations, the overall experience was quite insightful. I was a little surprised by the lack of deep computer science history, as the discussions leaned more towards current practices and future challenges, but that's not necessarily a negative, just unexpected.
This book offers some fascinating interviews with influential language designers, providing valuable insights even if their creations aren't widely adopted today. While it's definitely worth picking up, prepare for some drier sections; it's not a page-turner from start to finish. I felt it could have been significantly improved with more narrative and historical context woven throughout.
This book is truly exceptional, and I'd love to see more works of this caliber. The author masterfully delves into each subject, allowing the distinct personalities of the "masterminds" to really come alive on the page. You'll encounter everything from almost painfully evident arrogance to profound respect for peers, making for a thoroughly engaging and enlightening experience.
I was pleasantly surprised by this book, especially since I'd been putting off reading it for ages, assuming the history and motivations of language designers wouldn't grab me. Turns out, I was wrong! The discussions on language adoption, attitudes toward change, and marketing strategies were genuinely eye-opening and made for a much more engaging read than I'd anticipated.
While I only managed to get through the UML chapter, I found the interviews with the three authors to be quite inspiring, even when they strayed from the topic of UML itself. I've been jotting down all the interesting points and adding my own thoughts, though unfortunately, it's all in Czech. I'm looking forward to diving into the SQL and C# sections next, but I do wish there was a chapter on Pascal, a language I used extensively for over a decade before leaving programming.
This collection of interviews with language creators is pretty solid, though naturally, some conversations were more engaging than others. Your mileage may vary, of course, depending on your personal interests and how familiar you are with the languages discussed. It's a great choice for programmers of all stripes since there's hardly any code, making it accessible even if you're not an expert in every language featured. Still, I admit my focus did drift during interviews about languages I wasn't already acquainted with.
This book had so much potential, but it ultimately felt like a missed opportunity. While the interviewer is clearly knowledgeable, the editing is quite rough, making some interviews feel disjointed or poorly transcribed. Some of the interviewees also came across as surprisingly uninformed about developments outside their own specific language, which was a bit disappointing. It's a shame, as the concept itself was quite exciting.
This book was a real miss for me. While I've enjoyed similar interview-style books and even Stroustrup's "Design and Evolution of C++," this one just didn't land. The questions felt shallow, the responses lacked any real spark, and I found myself wanting more depth. After slogging through 100 pages covering languages like C++, Python, APL, Forth, and BASIC, I've seen enough, though I admit Forth still has a certain appeal.
This collection of interviews with creators of popular programming languages offers a fascinating glimpse into their thought processes. While the engagement level naturally varies depending on the interviewee, the overall quality is impressively high, revealing the obsessions that shaped these influential languages. It's a great way to understand the 'why' behind the code, though I personally would have loved to see interviews with LISP or Scala developers included.
This book is a fantastic read for programmers of all skill levels. The inclusion of interviews with language founders is particularly insightful, offering a wonderful glimpse into the recent history of the field.
This book is quite inconsistent; each chapter feels like it's written by a different person. You can usually tell within the first few pages if a chapter is worth finishing. Some contributors are incredibly tedious, rehashing the same points, while others speak in such abstract terms that you're left completely bewildered. Then there are those who spew pure marketing jargon, sounding like they're pitching their own language. Despite these issues, there are a few genuinely engaging discussions scattered throughout, with Haskell, Python, Fort, and Perl standing out as particularly worthwhile. A significant drawback, however, is the severe lack of code examples, often necessitating external tutorials to grasp the concepts presented.
While I only managed to get through the first few interviews, I found the sections on programming languages I'm familiar with to be somewhat engaging. However, the bulk of the content felt rather dull and uninspired to me. I'd suggest looking into 'Seven Languages in Seven Weeks' if you're keen on exploring various programming languages; perhaps an interview format would have been a better fit for that title, as a book solely comprised of interviews quickly became monotonous.
This book's interview format is a brilliant way to get inside the heads of programming language creators. You'll definitely see how much they all agree, but the differences that do pop up are truly striking and clearly shaped the languages we use today. While it can get pretty dense technically, it's incredibly insightful for anyone serious about computing history or language design.
Initially, I picked this up solely because of a recommendation, and my interest was limited to Java and SQL. The book presents itself as interviews with the creators of these languages, structured as Q&A sessions. The SQL section delves into its invention, the challenges faced, and offers insights that could be valuable for aspiring language creators, concluding with a discussion of XQuery. The Java part, however, felt less historical, focusing instead on design principles like simplicity and power, and touching upon AWT, Swing, the JVM, and debugging, including threading and API design. Ultimately, the author emphasizes that the true essence of language design lies not in the mechanics, but in understanding its purpose.
This book offers a fascinating glimpse into the minds of programming language creators, revealing their very human quirks and opinions. It's particularly interesting to read about Bjarne Stroustrup's defense of C++'s operator overloading over Java's approach, and James Gosling's strong feelings about C#'s unsafe pointers. The diverse perspectives, from Chuck Moore's radical ideas about bare-metal Forth interpreters to Anders Hejlsberg's bewilderment at Java's VM evolution, make for a compelling read. Bertrand Meyer's reflections on C#'s initial lack of generics and the long wait for code contracts, referencing his own Eiffel language, are also quite pointed. The mention of Meyer and Baudoin's early programming book, which apparently shaped generations of software engineers, adds a nice historical touch.
This book offers a fascinating glimpse into the minds behind programming language creation, revealing how personal biases and preferences heavily influenced their designs. It's a compelling exploration, though tackling it in one sitting might prove exhausting; it's best enjoyed as a sporadic read.
This book was a really enjoyable experience, though I have to admit it did drag on a bit. It's definitely a commitment, but the journey was worth it for the most part. I'd recommend it if you're looking for something engaging but don't mind a slower pace.
This book offers a surprising amount of wisdom on building systems for people, even though its primary focus is on programming languages. It's a highly recommended read for anyone looking to understand the human element in software development.
Even with a decade of experience in IT, I found this book to be remarkably relevant. While new technologies emerge constantly, fundamental concepts, much like basic arithmetic, remain timeless. The authors wisely focused on established, older languages like Perl, Python, C, Basic, and AWK, which have stood the test of time. This makes the book a true gem for both seasoned programmers and those interested in the history of computing, offering valuable insights despite its length.
This book offers a truly fascinating look into a complex and powerful design process, masterfully blending engaging qualitative insights about entertaining personalities with essential technical details. While a few chapters might feel a bit slower, the standout sections are excellent and plentiful. It's definitely one of the books I recommend most often.
While the APL interview and the language designers' predictions offered some intrigue, this book largely fell short. The early interviews, particularly those for C++ and Python, were disappointing, marred by uninspired questions and frankly sexist language that consistently defaulted to 'he' and made exclusionary statements about what constitutes a 'real programmer.' It's disheartening to see a book perpetuate such outdated and damaging attitudes. The AWK interview did provide some valuable insights into learning strategies, but it wasn't enough to salvage the overall experience. I can't really recommend a book with such significant flaws, though perhaps it might appeal to someone with a specific curiosity about a particular language.
This book dives into the minds behind programming languages, exploring not just their practical applications but also their inherent beauty and design elegance. While many interviews focus on mainstream languages like C++ and Java, the real gems are found in the discussions about languages from the 'margins' or those with unique design philosophies, like Basic, APL, Forth, and Eiffel. It's fascinating to learn that Perl, often perceived as messy, was actually designed with a linguistic, rather than mathematical, approach, making it surprisingly coherent. The authors sometimes overemphasize the need for deep mathematical knowledge for everyday programmers, but overall, the book inspires a desire to learn languages based on their interesting design and the vision of their creators, rather than just their immediate utility.
This book is quite substantial, but the interviewers really shine with their insightful questions, exploring a wide array of expert programmers and language designers. What I truly took away was a rekindled enthusiasm for the diverse world of programming languages and styles. It's fascinating how each creator, with their unique perspectives and opinions on the current landscape, set out to make a difference, whether by crafting a new language, fostering a community, or tackling a specific problem, often building upon the wisdom of those who came before. The process of language creation is a brilliant blend of scientific rigor and the distinct personal flair each designer injects. I'm now genuinely eager to dive deeper into languages like AWK, Haskell, Perl, and Eiffel after this read.
This book is fantastic, especially if you're interested in programming languages beyond just their utility for coding. The interviews with the creators of languages like C++, Java, and Python are incredibly insightful. The questions are thoughtful and respectful of the interviewees' expertise, leading to engaging discussions. You'll also get a kick out of how passionately each author defends their language's unique features, sometimes making you feel like their creation is the only one that truly matters!
Federico Biancuzzi and Shane Warden's 'Masterminds of Programming' is a substantial dive into the minds behind major programming languages, offering a wealth of information on language design, software engineering, and the history of computing. While the straightforward Q&A format is effective, I found the chapters on less familiar languages, like Forth and APL, to be surprisingly captivating, especially when learning about their development under hardware constraints of the past. The book is brimming with insightful quotes and historical context, though I do wish there were code examples to illustrate the languages discussed. Overall, it's a valuable resource for anyone interested in the evolution of programming.
This book offers a fascinating glimpse into the minds of programming language designers, revealing a perspective far removed from the usual programmer squabbles. It highlights how designers focus on fundamental principles rather than fleeting trends, and how their thoughtful considerations about language features and user needs contrast sharply with the often arbitrary choices made by everyday developers. Ultimately, the review suggests that programmers can learn a great deal from this more principled approach to language creation.
This book offers some interesting insights into programming language design, with engaging discussions and a palpable respect among the designers. However, much of the content feels like it could be found online, making the $39.99 price tag quite steep. While it held my interest, a concluding chapter with integrated analysis would have significantly boosted its value.
The chapter focusing on Eiffel and Forth was an absolute standout, offering some of the best reading in the book. However, I found that some of the language designers veered a bit too far into philosophical territory, straying from what I personally prefer in technical discussions.
This book is absolutely astonishing and offers a very tasteful and refined reading experience, though perhaps not a mandatory one. It stands out as a superb example of sophisticated interviewing techniques.