PDF Ebook 21st Century C: C Tips from the New School, by Ben Klemens
How can? Do you believe that you do not need enough time to choose purchasing book 21st Century C: C Tips From The New School, By Ben Klemens Don't bother! Simply sit on your seat. Open your kitchen appliance or computer system and also be on-line. You can open up or go to the link download that we offered to get this 21st Century C: C Tips From The New School, By Ben Klemens By this method, you can get the on-line publication 21st Century C: C Tips From The New School, By Ben Klemens Checking out the e-book 21st Century C: C Tips From The New School, By Ben Klemens by online can be truly done conveniently by waiting in your computer system and kitchen appliance. So, you could continue every time you have spare time.
21st Century C: C Tips from the New School, by Ben Klemens
PDF Ebook 21st Century C: C Tips from the New School, by Ben Klemens
Learn the strategy of doing something from lots of sources. One of them is this book entitle 21st Century C: C Tips From The New School, By Ben Klemens It is a very well understood publication 21st Century C: C Tips From The New School, By Ben Klemens that can be referral to review now. This advised publication is one of the all great 21st Century C: C Tips From The New School, By Ben Klemens collections that are in this website. You will certainly likewise locate other title and themes from numerous writers to look below.
If you obtain the published book 21st Century C: C Tips From The New School, By Ben Klemens in on the internet book store, you could additionally locate the very same problem. So, you have to move shop to shop 21st Century C: C Tips From The New School, By Ben Klemens and hunt for the readily available there. Yet, it will not occur below. The book 21st Century C: C Tips From The New School, By Ben Klemens that we will supply right here is the soft data idea. This is just what make you can conveniently discover as well as get this 21st Century C: C Tips From The New School, By Ben Klemens by reading this website. We offer you 21st Century C: C Tips From The New School, By Ben Klemens the very best item, always and constantly.
Never question with our offer, due to the fact that we will certainly constantly provide what you require. As like this updated book 21st Century C: C Tips From The New School, By Ben Klemens, you might not discover in the other place. However below, it's extremely simple. Merely click and download, you could own the 21st Century C: C Tips From The New School, By Ben Klemens When simpleness will ease your life, why should take the complicated one? You can purchase the soft file of the book 21st Century C: C Tips From The New School, By Ben Klemens right here and also be member of us. Besides this book 21st Century C: C Tips From The New School, By Ben Klemens, you could likewise locate hundreds lists of the books from several resources, compilations, authors, and also authors in worldwide.
By clicking the link that our company offer, you could take guide 21st Century C: C Tips From The New School, By Ben Klemens completely. Hook up to net, download, and also save to your device. Just what else to ask? Reviewing can be so very easy when you have the soft file of this 21st Century C: C Tips From The New School, By Ben Klemens in your gadget. You could additionally duplicate the documents 21st Century C: C Tips From The New School, By Ben Klemens to your office computer system or at home as well as in your laptop computer. Just discuss this great news to others. Recommend them to see this resource and also obtain their hunted for publications 21st Century C: C Tips From The New School, By Ben Klemens.
Throw out your old ideas about C and get to know a programming language that’s substantially outgrown its origins. With this revised edition of 21st Century C, you’ll discover up-to-date techniques missing from other C tutorials, whether you’re new to the language or just getting reacquainted.
C isn’t just the foundation of modern programming languages; it is a modern language, ideal for writing efficient, state-of-the-art applications. Get past idioms that made sense on mainframes and learn the tools you need to work with this evolved and aggressively simple language. No matter what programming language you currently favor, you’ll quickly see that 21st century C rocks.
- Set up a C programming environment with shell facilities, makefiles, text editors, debuggers, and memory checkers
- Use Autotools, C’s de facto cross-platform package manager
- Learn about the problematic C concepts too useful to discard
- Solve C’s string-building problems with C-standard functions
- Use modern syntactic features for functions that take structured inputs
- Build high-level, object-based libraries and programs
- Perform advanced math, talk to internet servers, and run databases with existing C libraries
This edition also includes new material on concurrent threads, virtual tables, C99 numeric types, and other features.
- Sales Rank: #104730 in Books
- Published on: 2014-10-12
- Released on: 2014-10-02
- Original language: English
- Number of items: 1
- Dimensions: 9.19" h x .92" w x 7.00" l, .0 pounds
- Binding: Paperback
- 408 pages
About the Author
Ben Klemens has been doing statistical analysis and computationally-intensive modeling of populations ever since getting his PhD in Social Sciences from Caltech. He is of the opinion that writing code should be fun, and has had a grand time writing analyses and models (mostly in C) for the Brookings Institution, the World Bank, National Institute of Mental Health, et al. As a Nonresident Fellow at Brookings and with the Free Software Foundation, he has done work on ensuring that creative authors retain the right to use the software they write. He currently works for the United States FederalGovernment.
Most helpful customer reviews
153 of 161 people found the following review helpful.
Essentially without competition, though far from perfect
By Alexandros Gezerlis
The C programming language is alive and well: it is used not only in vast amounts of legacy code but also in new development, often when efficiency is important and the learning curve imposed by C++ is deemed unacceptable. As for the literature on C, the standard high-quality text is the one by Kernighan & Ritchie (K&R), while the "second book" genre doesn't have too many representatives. Peter van der Linden's "Expert C programming: Deep C Secrets" and David Hanson's "C Interfaces and Implementations" are probably the best choices (perhaps supplemented by P. J. Plauger's "The Standard C Library"). However, given that all these books date from the 1990s or earlier, a book on modern C programming was sorely needed.
The Good: Ben Klemens' "21st Century C" is a text that assumes some knowledge of classic C and attempts to expand and update that knowledge. This has allowed the author to write a book that is not too long and can thus be read cover-to-cover. Even though this is not an elementary tutorial, the author has also included overviews of some basic concepts to make sure everyone's on board. The writing is for the most part pleasant enough and sometimes even humorous, e.g. "If you and a friend both have v1 [...] Or, if you have no friends". The code for the complete programs shown in the text has been packaged and is available on the publisher's website. Almost all of these programs are easy to compile and run -- this should go without saying, but unfortunately many books are rushed out too soon. One attractive aspect of this volume is that it contains a grab bag of tips (e.g. a function that takes in a pointer to void should immediately assign that to an appropriately typed pointer) as well as welcome summarizations of related topics, bringing to mind books like "Effective C++" and "Effective Java". For example, chapter 6 includes a useful table that goes over valuable aspects of static, automatic, and allocated storage duration (though Klemens doesn't use the standard terms "allocated" and "storage duration" but speaks instead of a "manual memory model"). A cute trick is given soon thereafter, in the form of a macro to initialize a static variable with a nonconstant value. More good macro material is included in later chapters, leading to convenient string-handling or helping us write functions that take in a variable number of named arguments. In the process of doing the latter, Klemens drives home a fun idiom: first define a struct, then define a variadic macro that puts its arguments inside a struct, and finally write a function that takes in a single struct as input. The main selling point of this text is that it's quite up-to-date, repeatedly mentioning C99 and C11. Importantly, the modern C features are not an afterthought but are used throughout the volume. Even so, chapters 9-12 would be the ones most useful to a reader unfamiliar with tools like strtok_s, designated initializers, the _Generic keyword, and anonymous unions. The last 2.5 chapters also attempt to inch toward programming in the large, with Klemens doing things like implementing a dictionary and using libraries (e.g. GSL and GLib) repeatedly. Speaking of libraries, Part I is dedicated to the modern ecosystem around C and is a charming departure from the language-centeredness of most programming books. Apart from giving basic usage info on debugging, Makefiles, and version control software, Klemens also introduces sleek tools like seq, pkg-config, and screen. One way to test an author's pedagogical skills is to evaluate a section containing material one is completely unfamiliar with. For me that applied to the sections on git rebase and on the variables appearing in Makefile.am; in both cases I felt the selection of topics as well as the explanations were nicely done.
The Bad: I begin by discussing structural problems and then go on to cover detailed issues. Klemens mentions in the Preface that "about a third of this book has almost no C code in it." First of all, Part I takes up 100 pages and Part II 150, so it's not really one third. Second, placing the non-C-specific material first leads to an excessive number of forward references. One example: p. 40 constructs the unit tests for a piece of code, p. 72 shows an Automake file that handles that testing, while the C program itself is introduced on p. 212. A related structural/misplacement issue has to do with Klemens' decision to introduce modern C features in chapter 10 (of 12). This wreaks havoc, given that he has (to his credit) opted to use new entities (like designated initializers and compound literals) throughout the text, even if he sometimes doesn't say he's doing so. Turning now to detailed issues, it's worth noting that the book contains many mistakes which are not just first-printing-typos, but flat-out factual errors. Here are a few examples, all drawn from a small fraction of the book: Klemens says that sources in distutils.core.Extension is "an array", even though it is a list of strings; he alleges that the stack size on Linux is limited to 2 or 3 megabytes -- stating this in apparent ignorance of the existence of ulimit and setrlimit; embarrassingly, the first use of pointers in the chapter on pointers contains at least two mistakes in one line (which is shown twice); he confusedly states that "the syntax for a function type is really a pointer to a function of a given type" -- this would mean that we could have array elements that are of function type, which is patently untrue. In other cases, the writing is slipshod: Klemens mentions "a local variable with static linkage" even though there is no such thing as static linkage in C (there's only external, internal, and none); he devotes an entire section to setting the array size at runtime but fails to note that variable-length arrays became optional in C11 -- later on, he can't make up his mind if such arrays can be initialized or not; he counterposes open to "the POSIX fopen" and refers to a "C-standard get_opt function"; he thinks he's uncovered a contradiction in K&R (just to be clear: he hasn't) but can't even be bothered to make the elementary distinction between declarations and definitions; the catalog of such issues is simply too long. In yet other cases, the text is characterized by plain old poor pedagogy, e.g. he defines list[3] and then talks about &list as if he's already explained what that means (when he's only discussed list and &list[0]). On a different note, we get a chapter on extending Python with C, but almost nothing on the impact of C/C++ feature differences. Bjarne Stroustrup has written an interesting article on C and C++'s "sibling rivalry" (which Klemens does not cite). Speaking of Stroustrup, the bibliography's only reference to "The C++ Programming language" is dated 1986 (presumably meaning the 1st edition). It's also worth noting that the bibliography includes two texts by Scott Meyers that are not cited in this book, but no reference to the volume by van der Linden that is the obvious competition in this niche.
In a nutshell, I liked the premise of the book much more than I enjoyed the execution. It was disappointing to see Part II start out by mentioning "especially complicated pointer setups like pointers to functions" only to repeatedly mishandle them near its end (both in the text and in the code). It should be noted that K&R managed to thoroughly discuss function pointers in one short section. Yes, expecting an author to match the quality of K&R is holding him to an impossible standard. But expecting him to write an authoritative and well-structured second book on C isn't as exacting. All in all, three stars.
Alex Gezerlis
27 of 28 people found the following review helpful.
Recommended for the self-taught programmer or intermediate programmer looking to fill gaps
By Alan Olsen
[This review was written for the 2014 Second edition.]
I have been programming for about 40+ years now. I learned C from a K&R first edition. Much of the bits of C I learned early on no longer work or are recommended these days. The language has changed, the tools have changed, and my watch has more than 1,000 times the memory of my first computer.
This is a book that gives a good refresher course in C. The author has a good knowledge of the history and structure of the language. He warns of the pitfalls and advantages throughout the book.
The book is not the average dry textbook. The style is light and readable, without being "jokey". I did not get bored with it, as I have with some other books.
The book not only covers C, but the tools needed to write good code. This includes Make, Git, GDB, autotools, and valgrind. (Among others.) It also covers a number of useful libraries that most C books ignore. (It does not suffer from the "here are the basics, fend for yourself" style of book.)
The OSes covered are Windows, Mac and Linux. It includes extra help for Windows and Mac, probably because if you are using those OSes, you will need it. (Linux has a much more complete toolchain for writing C code.) There is some mention of setting up a BSD environment, but much of that is covered in the Mac references. (OS X is BSD.)
The version I have is the 2nd edition. It covers C11 and some newer features of the OS and compilers that C programmers need to be aware of. It does not contain everything you need to know, but if it did it would be more than three times the length. The coding environment has been changing a great deal in the last 5-6 years, especially on Linux. This does not try to cover the OS interface issues such as UDEV or DBUS or the like. It is trying to show you more of the changes to the language, using the libraries as an example, not the changes to the overall libraries.
This is not the only book you need to become a good C programmer, but it is one that you will want to have in your library.
32 of 39 people found the following review helpful.
Ignore the curmudgeons and get stuff done!
By J. Austin
It's sort of amusing to read all the cranky one-star reviews of this book: "Why would you need a book? Just read the manpages!" "Real men don't use libraries or Autoconf!" "Go back to Ruby and Python you young whippersnappers!" "I don't like macros!" "Get off my lawn with your rock 'n roll and C11 (and C99)!" Wow, did the author graffiti an old folks' home or something?
Here on Earth, this book does for C what dozens of books have done for more modern languages like Ruby or C#. The book shows an intermediate to experienced coder in other languages how to hit the ground running in C. Since C is not exactly like those "other" languages, the advice isn't and shouldn't be the same as for those. You do have to deal with makefiles, and this book will show you several ways to do so. You can't avoid pointers, so he shows you how without pretending that pointers are deep mysterious difficult voodoo. C is not a "batteries included" language, so this book describes several libraries that you should use rather than e.g. implementing linked lists or Unicode handling from scratch by yourself.
By the same token, it's 2013 and C shouldn't be coded the exact way I was taught at university in 1995. Designated initializers prevent errors and make code easier to read. You don't need malloc() for runtime array sizing. It's fine to declare variables where they're used rather than at the top of the scope. Variadic functions are both underpowered and dangerous, but we can use them productively and safely with intelligently written macros using __VA_ARGS__. You still have to manage your own memory in C, but now there is Valgrind, the use of which this book illustrates clearly in a page and a half. Oh yeah, and we have libraries now, so you don't need to malloc() constantly while handling strings either.
I'm actually surprised none of the one-star fogies complained about all the struct-passing, of which I hadn't seen much before and of which there is a great deal in this book. I mean, if compilers in the 1980s only let you stuff so much on the stack, dooming us to ampersands and memory leaks, why should we acknowledge we have better compilers today? I almost suspect they haven't actually read the book...
It's your loss if my snark offends you. The author of this book is opinionated too. He quotes dissident punk bands with vulgar names at the beginning of chapters. He has specific recommendations for what tools to use and how to use them. In case you need convincing not to hobble yourself with an IDE, he shows you why a decent editor and the command line is better. He doesn't tell you how to use M$ tools because they suck (e.g. they're stuck forever on C89). The dozens of oddball build tools that have cropped up to replace make have failed to do so, and make is demonstrated repeatedly here to show you why.
I love K&R, but the world has changed since 1989, and this is the first C book I've read that realizes that.
21st Century C: C Tips from the New School, by Ben Klemens PDF
21st Century C: C Tips from the New School, by Ben Klemens EPub
21st Century C: C Tips from the New School, by Ben Klemens Doc
21st Century C: C Tips from the New School, by Ben Klemens iBooks
21st Century C: C Tips from the New School, by Ben Klemens rtf
21st Century C: C Tips from the New School, by Ben Klemens Mobipocket
21st Century C: C Tips from the New School, by Ben Klemens Kindle
Tidak ada komentar:
Posting Komentar