9 ms·
Who Says C is Simple?
- alco 13y ago> Why does the following code return 0 and not -1? This questions appears twice in the article. Note that shifting a 32-bit integer (no matter the sign) by 32 is undefined behavior (§6.5.7, 3). I'm using Clang, and its `int` has 32 bits even on a 64-bit system. C is deceptively simple.
- joshuaellinger 13y agoSimple Language != Simple to use. C is a small language. C is gussied-up assembly. It is the ballet of programming language. People who say C is simple really mean that it doesn't do anything behind my back.
- astine 13y agoC is like the marketing slogan to Othello (reversi): A minute to learn, a lifetime to master. The language is fairly simple in terms of features and aspects you have to learn to use it, but concepts like pointers and direct memory management are difficult to master. Programming in C is like building a building out of bricks; bricks are relatively simple objects, building a building out of them is not a simple task.
- JonFish85 13y agoAgree with both parents. "Simple" to me means that the code does exactly what I ask: no more, no less. For better or for worse. No behind-the-scenes magic (garbage collection, etc). I know exactly how much memory I am using, where it's allocated, and how it's passed around. Again, for better or for worse. With great power comes great responsibility!
- pjmlp 13y agoDo you also know all the undefined and unspecified use cases of the standard? http://de.slideshare.net/olvemaudal/deep-c http://de.slideshare.net/olvemaudal/deep-c
- anon1385 13y ago>No behind-the-scenes magic I assume you never compile with optimisations turned on then?
- zxcdw 13y agoHas very little to do with the language, apart from what undefined and platform dependent behavior allow the compiler to trick around. Of course, if the compiler goes nuts or is buggy, anything can happen "behind the scenes", but as far as I'm aware, this has nothing to do with the language as specified in the standard.
- ctdonath 13y agoThe problem is when what you ask for is incompatible with how it's done. Hence me today observing a price field in a record containing $9.500000000000000000002, knowing that making the obvious problem there "easy" will result in painful data manipulations elsewhere, and remembering that under certain conditions a Boolean can be neither true nor false. Asking a binary computer to handle non binary data just plain gets weird sometimes.
- deleted 13y ago[deleted]
- venomsnake 13y agoI think that pointers are hard is self fulfilling prophecy. We studied them in the 9th grade. Because nobody bothered to tell us they were hard almost my whole class - around 80% after the first two lessons groked pointers and linked lists. Same was with pointer arithmetic and function pointers. Right now I am struggling mightily with monads mostly because the voice in my head tells me the thing all of the internet is singing - they are hard don't bother.
- Genmutant 13y agoAlso the standard library is really small. So after a short amount of time you have used almost all of it a few times.
- PySlice 13y agoHowever it's going to take some time to learn all the gotchas in string functions... Failing to zero-terminate strings (strncpy), potential buffer overflows (many), global internal buffer and overwriting an argument (strtok), etc etc etc etc
- tel 13y agoIt "doesn't do anything behind my back" is exactly the phrase I've been searching for.
- pcwalton 13y agoBut the article contains many examples of the compiler doing things behind your back. For example: > The answer depends on whether the optimizations are turned on. If they are then the answer is 3 (the first definition is inlined at all occurrences until the second definition). If the optimizations are off, then the first definition is ignore (treated like a prototype) and the answer is 4.
- dietrichepp 13y agoIn that case, it's your fault for defining two versions of a function (inline and non-inline) that do different things.
- anon1385 13y agoEven if you don't do something like that a modern C compiler will do all sorts of things behind your back. Like removing null checks[1] or pointer overflow checks[2] [1] http://www.cvedetails.com/cve/CVE-2009-1897 http://www.cvedetails.com/cve/CVE-2009-1897 [2] http://www.cvedetails.com/cve/CVE-2008-1685 http://www.cvedetails.com/cve/CVE-2008-1685
- rapala 13y agoWell, to be fair, the NULL check was in a wrong place. The pointer was already dereferenced before the check. struct tun_struct *tun = __tun_get(tfile); struct sock *sk = tun->sk; unsigned int mask = 0; if (!tun) return POLLERR;
- anon1385 13y agoIs it a small language? The standard takes a dense 179 pages to describe the language. I guess it's debatable if that is small or not. I certainly don't agree that it's a simple language though. There are myriad rules and exceptions to rules to remember. When and where one integer type will be converted to another. When overflow is defined and when it's undefined. Just those things alone mean that much real world C code is full of undefined behaviour[1] just related to arithmetic on numeric types, because the rules are hard to remember and reason about. John Regehr asked people to submit str2long() implementations that didn't execute undefined behaviour. Despite being well warned about avoiding overflows and other undefined behaviour only 35 of the 78 submissions passed the test suite[2]. Even a trivially small 2 line C function can result in different results on the common compilers depending on which compiler and which optimisation level you use[3]. Compiler engineers struggle to agree on and correctly implement the "simple" rules of C. To me that's an indication that they aren't so simple. I would say that C doesn't do anything behind your back as long as you don't ever use an optimising compiler or you pay very very close attention to the standard. If you forget then suddenly your check for pointer arithmetic overflow has been "helpfully optimised away" behind your back for reasons that are not immediately apparent at all[4]. I do agree that apparently simple rules can lead to complexity in use, and C is full of this too. For example you would think in a lower level language like C viewing a chunk of memory as a different type would be trivial, but the strict aliasing rule means you have to be a language lawyer to understand what is allowed and what isn't[5] as it makes the intuitive solution into undefined behaviour (which is extra pernicious since most of the time it will work as intended, until somebody compiles the code with a smarter compiler at a high optimisation setting). [1] http://blog.regehr.org/archives/963 http://blog.regehr.org/archives/963 [2] http://blog.regehr.org/archives/914 http://blog.regehr.org/archives/914 [3] http://blog.regehr.org/archives/482 http://blog.regehr.org/archives/482 [4] http://pdos.csail.mit.edu/~xi/papers/stack-sosp13.pdf http://pdos.csail.mit.edu/~xi/papers/stack-sosp13.pdf example 1 [5] http://blog.regehr.org/archives/959 http://blog.regehr.org/archives/959
- TheCoelacanth 13y agoCompared to other languages, 179 pages for the full specification is pretty small. Java and C sharp have that more than three that size. C++ is roughly five times as large. If you're a fan of functional languages, Haskell is almost twice as large. Even Scheme, an extremely simple language, is only about 30 pages shorter.
- Kurtz79 13y ago"Terse" is the best adjective I can think of for C. Merriam-Webster definition of "Terse" : 1: smoothly elegant : polished 2: using few words : devoid of superfluity
- vadman 13y agoSimple != easy, as per this great talk by Rich Hickey: http://www.infoq.com/presentations/Simple-Made-Easy http://www.infoq.com/presentations/Simple-Made-Easy
- JeanPierre 13y agoTo get an even better explanation on what the word "simple" means and what it derives from, I would recommend "Simplicity Ain't Easy" by Stuart Halloway[1]. While it is very similar to "Simple made Easy", it focuses a lot more on the etymology of the words "simple" and "complex" and how people misuse the word. [1]: http://www.youtube.com/watch?v=cidchWg74Y4 http://www.youtube.com/watch?v=cidchWg74Y4
- omi 13y agoCan you explain number 4 in 16.2?
- qdpb 13y agoNobody? What these examples demonstrate is not that C is "hard", but that it's powerful.
- pjmlp 13y agoThere isn't a single feature in C that isn't present in more safer languages like Modula-2 or Turbo Pascal. They are as powerful, or even more, than C. Just because C won the battle with those languages, it does not mean we need to live with its design issues ad eternum.
- CoryG89 13y agoHow are you going to go about fixing C? And what design issues? It's pretty bare bones on top of the assembly. What should change?
- GregBuchholz 13y ago* Eliminate sources of undefined behavior * Remove implicit type casting * Have a way to check the hardware overflow flag from the language * Saner syntax for declaring variables (i.e. function pointers) * get rid of null-terminated strings * a module system instead of the preprocessor
- rootbear 13y agoI would not have thought that return ({goto L; 0;}) && ({L: 5;}); was valid C. GCC 4.4.7 chokes on it, using -std=gnu99. Is this a C11 thing?
- DerekL 13y agoNo, it's a GCC extension. That entire section is about non-standard GCC features.
- apaprocki 13y agoTo the compiler, it shouldn't care where a label exists. If you're telling it to go to label L:, execution will jump there. GCC appears to look out for the programmer and always prints an error (and I don't see an option to shut it off). Oracle Studio compiles it with no issue and the above statement returns 1.
- mikestew 13y agoI just slapped it into Xcode and compiled using LLVM 4.2 (-std=gnu99), and it works fine. Using Xcode's LLVM GCC 4.2 setting (-std=gnu99 by default), it chokes. Conclusion: I kind of lost interest at this point. :-) I don't quickly know how to get it to compile using GCC, though.
- EthanH 13y agoSomeone else at Cal summarized C succinctly when he wrote "C is the machete of programming languages. It's great for clearing a quick path through the jungle of programming problems, but be alert as there are no safety mechanisms to protect the wielder of this wonderful weapon." -David Patterson http://www.informit.com/promotions/promotion.aspx?promo=138913 http://www.informit.com/promotions/promotion.aspx?promo=1389...
- pjmlp 13y agoWarnings as errors, turn on all of them, pedantic mode and static analysers running alongside unit tests on every build. Even then, there might be dragons waiting for you.
- nautical 13y agohttps://news.ycombinator.com/item?id=6059249 https://news.ycombinator.com/item?id=6059249
- harrytuttle 13y agoAll this proves is that you can write ugly C and GCC has some crocks in it. These problems are all optional.
- dvt 13y agotl;dr: C is simple. Bad code is bad. Shitty compilers are shitty. This needs to be qualified. Simple compared to what? C is simple when compared to C++, Java, and many other languages. Obviously, C is simple because it lacks syntactic sugar, classes, polymorphism, templating (generics), memory management, etc. So, uh, yeah. It's simple. The fact that bad code can be written in a language doesn't really make the language non-simple. I could write bad code in any language (often times I do!) - so I'm not sure how any judgment about a language can be made with these kinds of examples. As far as the GCC/VC examples are concerned, they are a non-issue. Shitty compiler keywords are shitty[1]. We know. This is one of the many pains of writing cross-platform code in compiled languages. These examples are contrived and I highly doubt most come from production code. [1] http://stackoverflow.com/questions/3437404/min-and-max-in-c/3437484#3437484 http://stackoverflow.com/questions/3437404/min-and-max-in-c/...
- 14113 13y agoC is simple like the game Go is simple. Both are defined by (comparatively) simple rules, yet the possible situations that both present are far more complex than languages or games defined by far more complex rules.
- kbenson 13y agoIn that vein, assembly languages are even simpler. Which is true. The languages themselves are simple. Their use often isn't.
- aylons 13y agoNo, assembly languages are not simpler, except for a few processors, mostly didactic. Programming in assembly generally requires understanding registers, how the processor works, lots of branching variation, a few other ways to loop, memory organization on the processor, and at least tenths or hundreds of different opcodes, some with surprisingly subtle differences between them. So, no, ASM is not simple the way C is.
- deleted 13y ago[deleted]
- rdtsc 13y ago> Who Says C is Simple? I do. C is like chess. There are few simple rules (compared say to C++ spec). But knowing the rules doesn't mean you'll end up beating Kasparov. It still takes skill and practice to be a good C programmer. So, the language itself, is pretty simple compared to other popular programming languages as far as it has a simple syntax. I can teach someone the rules of chess pretty quickly, It doesn't mean I'll create a chess grand-master in a day or two.
- gnuvince 13y agoThe difference is that I don't want my programming language to take me a lifetime to become reasonably skilled with it. There are many languages that are simpler than C, and easier to use as well.
- foobarbazqux 13y agoI bet most or all of the languages that you're thinking of run on a VM written in C.
- cygx 13y ago>> Who Says C is Simple? > I do. I disagree. C comes with a lot of edge cases and subtleties that can surprise even people like myself who 'know' C. Some examples: Exact semantics of restrict, C99 inline semantics (eg I wasn't aware that it's possible to make a non-extern/non-static inline definition into an extern one with a single redeclaration), effective typing rules and whether it's possible to circumvent them, whether or not it's undefined behaviour to cross boundaries of the sub-arrays of a multi-dimensional array if it doesn't happen in a single expression, ...
- rdtsc 13y agoThe difference is between gimmicky ways one can use ambiguity to produce convoluted edge cases vs knowing enough to do actual work. Sure C being low level and and having a relatively short specification is ripe for compiler specifics and hardware specific hacks. But still think it has the basic core defined and that is pretty small. With C++ and its typical libraries it is a bit different. It has so many features (templates, classes, streams, friends, shared pointers, unique pointers, distructors, constructors, polymorphism rules, and combination of those) that code gets complicated without using obscure features, just sticking to the standard ones gets hairy and needs someone who knows the whole spec.
- deleted 13y ago[deleted]
- null_ptr 13y agoThese little teasers are starting to annoy me. Congratulations, you can twist C to be as unintuitive as you'd like it to be. But why would you write code like that to begin with? I don't care what value __ return -3 >> (8 * sizeof(int)); __ returns because no sane program anyone contributes to will have constructs like that.
- eps 13y agoYou are missing the context, which is that of an unambiguous parsing of any valid C code. Examples given are teasers for the parser, not a prorammer.
- ximeng 13y ago"The following examples were actually encountered either in real programs or are taken from the ISO C99 standard or from the GCC’s testcases."
- acjohnson55 13y agoC is not a simple language. It is confoundingly difficult for a machine to parse. Add in the fact that it pretty much requires a preprocessor to be useful and it get's even more difficult. Clearly the article is not about whether the C paradigm is complex. It obviously isn't, because it doesn't come with a whole lot of pre-baked abstractions. But for parsing reliably, it's an absolute nightmare.
- auctiontheory 13y agoC is a tool. A powerful and flexible tool. If a programmer wants to write obfuscated code (as in the examples), C allows that. If a programmer wants to write clean, maintainable and documented code, C allows that too.
- bwy 13y agoGo Berkeley, awesome prof.