News for hackers. Stuff that matters.
Re:The Resurgence of C Programming by jstewartmobile on Tuesday December 27, 2016 @02:23PM (#13265449)
Whenever C gets brought up, people are like, "pointers... memory... dangerous!" In 20+ years of C, I've never had a (self-inflicted) problem in that area. Maybe I'm the rain man of bit-twiddling?

What has caused me tremendous grief are all of the inconsistencies in the compilers, the gotchas of the precompiler, and the ambiguities in the language itself. C++ is even worse.

Rust is great, but not great enough to justify a redo of a program that has been extended and maintained for decades (like vim or photoshop).

I think an iterative tightening of the language would be of greater utility to everyday computing than a rush to re-do everything in something "better."

Re:The Resurgence of C Programming by pavlov on Tuesday December 27, 2016 @04:44PM (#13266463)
I always felt that Objective-C was a great take on a "better C"... Definitely not conceptually better in the ways that Rust is, but simply better for a lot of the practical things where C suffers the worst.

Obj-C was an appealingly simple extension to C from the compiler point of view, but for a long time it was hobbled by the runtime/framework situation, as the NeXT/Apple runtime wasn't open source.

Just as that compatibility hurdle was getting fixed by open source efforts around 10 years ago, the iPhone happened and Apple went nuts with extensions to the language... It used to be that Objective-C proponents would brag that you can learn the syntax in 5 minutes if you know C. Now the language is filled with uncountable double-underscored keyword warts and @ declarations. Today's Obj-C looks more like an intermediate format for a Swift->C compiler rather than an evolution of Obj-C 1.0.

I understand completely why that happened. I just wish that Obj-C had gained more of an open source foothold when the opportunity was there, so it wouldn't have been so dependent on Apple's stewardship which eventually killed it as an independent language.

Re:The Resurgence of C Programming by WalterBright on Tuesday December 27, 2016 @07:53PM (#13267618)
Back in 1986 or so, there were two languages based on C: C++ and ObjectiveC. I was casting around looking for an edge with my C compiler, and investigated the two.

On usenet, there was about the same amount of traffic in the C++ and O-C newsgroups, the respective communities were about the same size.

Which should I choose? ObjectiveC was produced by Stepstone, and they wanted a royalty. C++ was produced by AT&T, and I phoned up their lawyer who said no royalty was required.

So I picked C++ based on that.

In 1987 I shipped the Zortech C++, the first native C++ compiler, and the popularity of C++ promptly zoomed. (Yes, I do think ZTC++ had a lot to do with the crucial early surge of C++ adoption, because the PC was where the programming action was at the time, not Unix.) The traffic in the C++ newsgroup exploded, and the ObjectiveC traffic crashed.

O-C was dead until Apple picked it up again later.

Re:The Resurgence of C Programming by tomcam on Wednesday December 28, 2016 @09:49AM (#13270769)
Dude's not wrong about Zortech's influence, young'uns. It was truly a game changer. Love the anecdote about calling the lawyer!
Re:The Resurgence of C Programming by WalterBright on Wednesday December 28, 2016 @10:04AM (#13270889)
I not only asked him about royalties, I asked him if I could call it "C++". He laughed, and said nobody had ever asked that before, they just did it. He was very nice and said I was welcome to use it.

I wish I remembered his name. He was a good guy.

I also remember how nice Andrew Koenig was to me in the early days. All the C++ people were nice, but Andy was a standout.

Re:The Resurgence of C Programming by pavlov on Wednesday December 28, 2016 @08:08AM (#13270210)
Great perspective, thank you! I would definitely agree that your early C++ compiler on DOS had a huge impact on the language's popularity.
Re:The Resurgence of C Programming by mpweiher on Tuesday December 27, 2016 @05:14PM (#13266676)
Hear hear!

And then I watch something like Gary Bernhard's "Boundaries" talk[1], which isn't bad, mind you, and think "maybe this Brad Cox guy with his Software ICs really knew what he was talking about?"

Where Apple went off the rails with Objective-C was trying to make it into an OO language like Java. It isn't. It is a deliberate hybrid, with a component implementation language ("C") married to a component connection language ("Objective").

My own approach is to take this distinction seriously, and instead of doubling down on the "better Java" part like Swift does (which in Software-IC terms is focusing on the less interesting and mostly solved component implementation part) and instead expand on the ways we can connect components (dataflow, constraints, storage composition, etc.).[2]

Minor correction: GNUStep, libFoundation etc. happened around 20 years ago, not 10.

[1] https://www.destroyallsoftware.com/talks/boundaries

[2] http://objective.st/

Re:The Resurgence of C Programming by Volt on Tuesday December 27, 2016 @07:51PM (#13267611)
>trying to make it into an OO language like Java. It isn't.

Can you elaborate? In what ways?

Re:The Resurgence of C Programming by pcwalton on Wednesday December 28, 2016 @09:29AM (#13270662)
Objective-C is just an idiosyncratic COM-like system with first-class language support (something that COM desperately needed). There's a performance ceiling with Objective-C that C++ doesn't have, due to some key decisions early on that make it much more like COM than C++—pervasive atomic reference counting everywhere, mandatory heap allocation, virtual dispatch requiring (caching) hash table lookups, and so forth.

I think if Objective-C had caught on and C++ hadn't, the performance-critical world would look very different: you'd probably just see those domains stick to C.

Re:The Resurgence of C Programming by pavlov on Wednesday December 28, 2016 @11:18AM (#13271467)
I honestly wouldn't mind a world where Obj-C had been used to filled all the COM-shaped holes in PC operating systems, including Windows and Linux desktop...

Obj-C is a great solution for messy GUI code and OO plumbing when you still need seamless C interoperability. COM and its various C++ wrappers tried to solve the same problem, but fell short in so many ways. On Linux, Qt and Gtk+ both built their own incompatible and inferior solutions to the same problem.

Re:The Resurgence of C Programming by eschaton on Tuesday December 27, 2016 @05:10PM (#13266642)
The NeXT/Apple Objective-C runtime has been Open Source since the late 1990s, the API and ABI have been documented since the late 1980s so anyone could create a compatible runtime, and GCC has had a portable runtime almost since Objective-C was taken into its mainline.
Re:The Resurgence of C Programming by favorited on Tuesday December 27, 2016 @05:12PM (#13266649)
I can agree about the nullability annotations & generics additions, but having properties, ARC, & blocks made writing Objective-C programs so much nicer, IMO.
Re:The Resurgence of C Programming by blub on Wednesday December 28, 2016 @06:12AM (#13269820)
Objective-C will slowly move to where it belongs - the dustbin of programming language history.

Merging C with a higher-level language could only make sense in the 80s, where people didn't know better and invited all the dreadful problems of C code into application development.

Swift is the proof that one can have a safe, powerful language that can also be fast. It's not yet fully mature, but it will get there, the speed at which it's replacing Obj-C in iOS and macOS development is impressive.

Re:The Resurgence of C Programming by 35bge57dtjku on Wednesday December 28, 2016 @10:49PM (#13275519)
I've never seen its syntax not look bad enough that I immediately abandoned all hope of using it ever.
Re:The Resurgence of C Programming by psyc on Tuesday December 27, 2016 @02:54PM (#13265721)
I agree with you. I've been a C and C++ programmer for decades, and nothing to do with memory safety or leaks has ever risen to the level of prohibitive or even annoying. Ironically, I've had infinitely more grief from fighting hostile garbage collectors, but that's because I'm a game programmer. I quickly dropped Rust upon realizing that the core of the language addresses problems I don't have.

I'm always met with strawman arguments about how I can't possibly write "correct" code. It's a strawman because I don't claim to write correct code. I don't care if Herb Sutter can find 1000 "bugs" in my C++. I care that my users and myself are happy.

Re:The Resurgence of C Programming by pcwalton on Wednesday December 28, 2016 @09:21AM (#13270606)
I've heard this criticism from several game developers at this point. Contrary to some other voices here, I do think it's legitimate: if safety isn't important to you, then I can't argue with that.

At the same time, I think that Rust made the right choice for most domains. For most software, memory safety problems that hostile attackers find have consequences. Games are an exception, not the rule. It would be irresponsible for us to target servers or network-facing client software without memory safety.

It's also of course true that we have many game developers in the Rust community. A lot of people, including me, see safety as a productivity booster, especially combined with all the other features in Rust. I've advanced suggestions in the past for making unsafe Rust easier to program in, effectively turning off some of the safety checks, specifically for game developers who would prefer not to have the restrictions. These suggestions have been very unpopular in the Rust community, including from the game devs, and so they haven't gone further.

Re:The Resurgence of C Programming by dikaiosune on Wednesday December 28, 2016 @01:01PM (#13272261)
I'm a little confused game developers are so dismissive of attack surface -- after all, most games I've played in recent memory have some level of network access (multiplayer, achievements, etc.), and very few game developers seem to be OK with rampant exploitation in their online communities.
Re:The Resurgence of C Programming by psyc on Friday December 30, 2016 @03:28AM (#13283257)
Am I dismissive of the catastrophic effects of being shot, because I never wear a bulletproof vest? Again, not every individual app has the same problems. I'm not working on WoW. My best guess as to the number of people trying to attack my games is honestly zero.
Re:The Resurgence of C Programming by khedoros1 on Wednesday December 28, 2016 @04:22PM (#13273782)
"Never trust the client". The assumption should always be that the game client is lying to the server, whenever that's possible. In multiplayer games, a stream of keypresses is sent to the server, and a game state is sent back to the client.

At least, that's part of the argument that I assume they'd make.

Re:The Resurgence of C Programming by dikaiosune on Wednesday December 28, 2016 @04:25PM (#13273811)
Totally, although I assume at least some game shops are using shared C++ libraries on both client and server.
Re:The Resurgence of C Programming by unscaled on Tuesday December 27, 2016 @04:39PM (#13266416)
The real problem with C (and to a lesser extent C++) nowadays is not just memory leaks or segfaults, but all the security vulnerabilities you get from the lack of memory safety.

Your code might work 100% correctly for your users, but it may also put their system into risk when processing arbitrary and potentially malicious data. When your system needs to handle data that may come from anywhere - and almost every system does - writing Herb Sutter-correct code is no longer just a nice-to-have.

Re:The Resurgence of C Programming by psyc on Tuesday December 27, 2016 @05:33PM (#13266800)
A big part of the point I meant to make is the difference between theoretical problems and practical problems, and how priorities and risk vary a lot across applications. The number of complaints I've received about malware targeting my games over the last 25 years is exactly zero. So when I go looking for my perfect language, that's not a problem that I'm trying to solve. I'm not arguing that other languages shouldn't exist, I'm saying they don't address the most important problems in my domain (roughly, expressiveness and performance).
Re:The Resurgence of C Programming by dozzie on Tuesday December 27, 2016 @08:49PM (#13267847)
> A big part of the point I meant to make is the difference between theoretical problems and practical problems, and how priorities and risk vary a lot across applications.

And this is how we had ILoveYou and similar viruses. In the name of the whole internet, I hereby thank you very much for your hard work in this matter.

Re:The Resurgence of C Programming by tim333 on Wednesday December 28, 2016 @06:28AM (#13269871)
ILoveYou was an email attachment virus. Email attachments are forever being targeted, games less so.
Re:The Resurgence of C Programming by kazinator on Tuesday December 27, 2016 @11:26PM (#13268411)
I would say, far lesser extent C++ (unless you're just writing C and compiling with a C++ compiler).
Re:The Resurgence of C Programming by htns on Tuesday December 27, 2016 @04:44PM (#13266462)
That might be the chorus when it comes to selling new languages, but there is no reason C could not be compiled with memory safety. It is not done because by the end of the day people don't care for safety much.
Re:The Resurgence of C Programming by nickpsecurity on Tuesday December 27, 2016 @05:13PM (#13266658)
It's obviously not happening because C's design... especially lack of any guarantees... combined with what those checks required made complete, memory safety hurt performance a lot. Talking multiples worse (300+%). Things like Softbound+CETS and Criswell's SAFEcode have gotten it down below 100% worse performance in many cases. Others seem to explode in delay on specific routines due to how they interact with the bookkeeping methods.

Whereas, Ada, Wirth, and Eiffel languages were designed to make the job easier for users and tooling. SPARK was even tailored to make it easy to prove absence of C-style vulnerabilities with automated proving. That was done by a small team over a period of years whereas global assortment of teams putting decades into static analysis or proof tools for C haven't pulled that off outside even more restrictive tools like Astree Analyzer.

C is just inherently bad for safety despite safe ways of doing it existing. That's because it was designed almost exclusively to run fast on a PDP-11. That simple. On other end, Hansen wrote Edison for a ultra-minimal language for a PDP-11. It was smaller than C, easier to process, and still had safety features. Reiterates it was simply a personal preference by C's designers to not care about safety while many others did.

Re:The Resurgence of C Programming by pjc50 on Tuesday December 27, 2016 @05:23PM (#13266721)
As a game programmer, exploitability is fairly low on your list of priorities, but for other systems it's quite important. If hackers can find 1000 bugs in your C++ that get them remote access to your computer through the browser, ... well, this is why people hate Adobe.
Re:The Resurgence of C Programming by stymaar on Tuesday December 27, 2016 @05:08PM (#13266623)
> I don't care if Herb Sutter can find 1000 "bugs" in my C++.

Until the new release of GCC improve its performance by 10% by optimizing more cleverly an Undefined Behaviour but OOPS it now breaks your code …

> I quickly dropped Rust upon realizing that the core of the language addresses problems I don't have.

Rust isn't only about safety, it's also a «C++ on steroid from 2015» with a ton of cool features : Modern type system, no null pointer, parallel code without fear, package manager …

Rust is a huge productivity booster IMHO !

Re:The Resurgence of C Programming by naasking on Tuesday December 27, 2016 @04:10PM (#13266206)
> I quickly dropped Rust upon realizing that the core of the language addresses problems I don't have.

There are plenty of other expressiveness advantages to Rust, over and above the safety advantages you apparently wouldn't benefit from.

Re:The Resurgence of C Programming by psyc on Tuesday December 27, 2016 @05:06PM (#13266606)
The problem is that stuff like ownership and mutability are explicit and smack in the center of the language. They're not optional. I don't want to write those semantics at all.
Re:The Resurgence of C Programming by nickpsecurity on Tuesday December 27, 2016 @05:18PM (#13266698)
How would you feel about Modula-3 without the upper-case and a bit less verbosity? It was industrial development of Wirth's philosophy at DEC. I always thought it did the best of the safer languages balancing features, simplicity, safety, fast compiles, and runtime performance. Example is built-in concurrency, simplified (optional) OOP, and deciding on per variable basis whether to use garbage collection.

https://en.wikipedia.org/wiki/Modula-3

I've considered rebooting it with a few modern lessons built-in plus some Ada safety features. Everything transparent where it doesn't go into the language unless it's easy to work with and consistent. Add Scheme-like macros and good FFI for C like in Julia.

EDIT: I just saw your comment about cherry-picked subset of C++. That's how I describe Modula-3 in many comments elsewhere. Now I'm extra curious what gripes you may have with it.

Re:The Resurgence of C Programming by lobster_johnson on Tuesday December 27, 2016 @10:07PM (#13268134)
"Upgrading" Modula-3 is an interesting idea, but I wonder how much you'd have to tweak for it to be worth the effort. I suspect that adding a new chrome would end up as something awfully like Go.

Go, in my opinion, is currently the best distillation of the Wirth progression of languages that we have. The Go authors (one of whom worked on Oberon-2 at Wirth's ETH Zürich) took a lot of inspiration from Wirth, and Go is in many ways a reactionary language as a result: A simple, strict type system; easy to parse (Wirth's languages all famously fit on a single screen of EBNF grammar, not sure if Go is quite that small); design choices favouring the pragmatic over the theoretical (ignoring the last 30 years of type theory), reasonably performant, etc.

I'm not sure there's that much left in the original well. Modula-3 did have a "safe" construct, but it seems a bit naive today (nowhere near Rust's advanced, complicated safety features). Explicitly choosing between GC/non-GC seems like something compiler writers should be able to automatically optimize. Modula-3 did have generics, of course.

Re:The Resurgence of C Programming by nickpsecurity on Tuesday December 27, 2016 @11:05PM (#13268356)
I think it could be a bit better if it got close to Ada's safety features without their unusability. I was considering adding a borrow checker, ref counting, and Go-style GC to it for various use cases. Idea being people could choose along spectrum from quick prototyping with reasonable performance to hard work for safety without GC. Add Design-by-Contract support from Eiffel with SPARK-like static analysis on modules simple enough to allow it. Complex modules could be analyzed easier than C since it's a Wirth-style language. Port either Rust's or SCOOP's concurrency model so it's safe-by-default. Maybe a few things from functional programming for decoupling of modules without getting too much overhead.

I don't think it has to be Go language or have nothing we've learned from type theory while being easy to use. Just has to have a base as easy to use as Go with options to bring you closer to Ada, Eiffel, or Rust in safety + performance. Plus macros maybe with compiler being LISP on inside for ultra-easy transforms like Julia did. :) The combination should be quite advantageous where baseline of safety & maintenance is achieved at Go speeds with effort of rest increasing other attributes.

That was my brainstorm on it anyway. It's all up for debate outside the part where it would be easier to learn & compile than Rust or Ada. Their strategies are intrinsically complex vs a Wirth language with some upgrades.

Re:The Resurgence of C Programming by lobster_johnson on Wednesday December 28, 2016 @12:17AM (#13268589)
I think a language like that could be great if you managed to synthesize all the good parts into a modern whole.

I always liked the very pragmatic mechanism, in Wirth's languages and in Ada, of attaching constraints to data types; for example, defining a type as an integer of range 1..9. On the one hand, from a type-theoretical viewpoint, it's completely cheating — the mechanism is hardwired into the language, there's no real underlying system or symmetry to it, unlike a proof-based language such as Idris or Agda. On the other, it's awfully pragmatic.

Re:The Resurgence of C Programming by pjc50 on Tuesday December 27, 2016 @05:27PM (#13266753)
Modula-3 sounds interesting, from a couple of fans I've spoken to over the years. I'm curious as to how it was simultaneously (a) taught in universities for years and (b) completely forgotten in the popular culture.
Re:The Resurgence of C Programming by ArkyBeagle on Tuesday December 27, 2016 @06:57PM (#13267359)
There used to be a big ad for Module-2 ( not 3 ) toolchains in the back of Byte magazine ( when it was relevant ) but they were all bytecode interpreted, and not as performant as 'C'.

Universities weren't that relevant back then. Fully half the people I worked with through the end of the 20th Century did not have CS degrees.

Re:The Resurgence of C Programming by Nomentatus on Tuesday December 27, 2016 @11:26PM (#13268413)
In good part because Universities where I was (partly due to donations and funds from IBM) did not tolerate microcomputers, connect to them, and refused to put in a single course regarding them. PC's weren't classy, they were only the future.
Re:The Resurgence of C Programming by nickpsecurity on Tuesday December 27, 2016 @05:52PM (#13266946)
It's a social and economic phenomenon. It happens so much I discussed here the possibility of creating some central resource for knowledge in programming, security, etc specifically designed to prevent it. It would have an accompanying forum of people vetted to know about various tech or skills. That way experienced people can pass the wisdom onto new crowd to cut down on some of the fads or at least how they deafen everything.

A number of companies used Modula-3 experiencing its benefits. Only use I recall in FOSS that was widespread was CVsup which was since rewritten.

https://modula3.elegosoft.com/pm3/intro/questions/whym3.html

Re:The Resurgence of C Programming by psyc on Tuesday December 27, 2016 @05:22PM (#13266720)
Unfortunately, I'm not familiar with Modula-3 or Ada. But I will look into them. Thanks.
Re:The Resurgence of C Programming by nickpsecurity on Tuesday December 27, 2016 @05:32PM (#13266793)
Oh wait, if doing Ada, then take this link:

http://www.adacore.com/knowledge/technical-papers/safe-and-s...

Remember as you read it that it starts a bit from scratch in the 1980's mainly for embedded, real-time systems that can't fail. The thing to focus on as you skim table of contents or chapter contents is they systematically find the constructions that screw people up, statically prevent them where possible at type system, catch others dynamically by default, and let you drop to unsafety where necessary. The range types (esp existential types), ability to control bit layout, & concurrency safety are old favorites of users in safety-critical space.

SPARK is a subset of Ada with extra annotations to help it catch errors statically. It can, with automated provers, show the most common problems can never happen in your code. Here it is:

http://www.spark-2014.org/uploads/itp_2014_r610.pdf

http://www.spark-2014.org/about

Re:The Resurgence of C Programming by naasking on Wednesday December 28, 2016 @12:16AM (#13268581)
Sorry, I still don't see it. Once you internalise the logic of Rust's borrow checker, you'll see that probably 80% of your code already follows this discipline and would pass the borrow checks without trouble.

Some small amount of code is probably hiding mistake in various corner cases which the borrow checker will point out. The remainder is legit safe code, and you can use unsafe annotations to do what you would do in C.

So you're throwing away a powerful tool just because it impacts maybe 5% of the code you want to write, but not even in a way that would really impede you in the end.

Re:The Resurgence of C Programming by jstewartmobile on Tuesday December 27, 2016 @02:57PM (#13265748)
Sometimes you have to wonder if these admonitions from industry trendsetters are really just sneaky tricks to slow the rest of us down...

"Hey, that C++ code that's been working for years? All wrong! Go rewrite it in Node.js. No, no, no, in Go this time. Now Rust!" ...

Re:The Resurgence of C Programming by pcwalton on Wednesday December 28, 2016 @09:23AM (#13270617)
> Sometimes you have to wonder if these admonitions from industry trendsetters are really just sneaky tricks to slow the rest of us down...

No, I didn't work on Rust for the past six years while sitting in the office twirling my mustache trying to think of ways to slow the industry down.

I worked on it because we kept seeing the same issues come up again and again and again.

Re:The Resurgence of C Programming by pdimitar on Tuesday December 27, 2016 @03:04PM (#13265791)
I absolutely don't disagree with both of you.

That being said, I've been knowing game developers for years and while I don't know their exact complaints, they kept saying they wished they were working with something else than C++.

I think it's mostly solving the same problems many times over and over, during their entire career.

Re:The Resurgence of C Programming by psyc on Tuesday December 27, 2016 @05:14PM (#13266673)
I do wish I was working with something else. Something I'm still surprised doesn't exist yet. I understand the reason it doesn't exist is that a cherry-picked subset of C++ is good enough. This hypothetical language would be a greatly simplified C++ with a couple dozen small annoyances smoothed over.
Re:The Resurgence of C Programming by buserror on Tuesday December 27, 2016 @07:32PM (#13267518)
Well, you CAN do simplified C++. Apple even had their own version of it called 'Embedded C++' (the drivers in OSX are like that) -- basically, remove RTTI, exceptions, templating and a few other bits and you get a C with namespacing, objects, nice context-based stack based objects and a few other nice things, without the bloat.

So, yes technically you CAN write nice lightweight C++; but you won't be able to enforce it in a team, as everyone will need 'their' pet feature of doom to bring back the bloat.

How do I know? Well, I tried for years to do it like that; and eventually I had to give up. Now I do plain C, because it can't be corrupted in the same way.

"But, but, I just #included <vector>!!"

"... What, for a 5 byte constant array?"

"Yeah I know, but the compiler will just inline it!"

Re:The Resurgence of C Programming by shakna on Tuesday December 27, 2016 @10:54PM (#13268312)
Or worse:

    #include <boost/fusion/container/vector.hpp>
"Why do we need Boost for this single vector?"

"Well... We're using Boost elsewhere..."

Now we use C. Not C++.

Re:The Resurgence of C Programming by quicknir on Wednesday December 28, 2016 @03:41PM (#13273434)
If someone is using a vector for a small array of fixed size in C++, in a place where performance matters, then their knowledge level is so low that you are going to have issues with them no matter what, I'm afraid. Knowing that vector uses the heap is beginner level knowledge.

On the other hand, in C you are stuck with a built in array now. If you pass this to a function that doesn't get inlined, it will decay into a pointer, then inside that function the compiler has actually "lost" knowledge of the size of the array. Now you have to pay for a loop.

In C++ you can pass a std::array by const reference, the compiler knows exactly how big that array is at all times, and for small arrays the loop checks can be eliminated entirely.

Many of the arguments against C++ boil down to: if you're working with a lot of people who have a knowledge level below what I would expect someone with 1 year of good experience to have, then they can make more mistakes. Is the level of developers generally really that low?

Re:The Resurgence of C Programming by lacampbell on Thursday December 29, 2016 @01:42PM (#13279105)
On the other hand, in C you are stuck with a built in array now. If you pass this to a function that doesn't get inlined, it will decay into a pointer, then inside that function the compiler has actually "lost" knowledge of the size of the array. Now you have to pay for a loop.

To which my answer would be "write your own". Whenever I program in C I always use my own dynamic, bound checked arrays that store their own length.

I am often surprised that many C programmers often don't build their own abstractions. The OpenSSL library is a prime example of this - the same 4 or 5 arguments passed in the same order to hundreds of functions. I am always surprised they didn't just make a struct.

Re:The Resurgence of C Programming by quicknir on Friday December 30, 2016 @12:15PM (#13285531)
You are missing my point.

It can store it's own length, but the compiler will still not be aware of the length, except in a real local context (i.e. in the same block of code, either actually, or via inlining). So if you decide to loop over your array, you have to pay the price of looping (jumping and comparing).

If you know that you are working with an array of fixed length, and you use a C++ std::array, you can pass this by reference to functions and those functions will know at compile time how long the array is. So you don't have to pay for looping at all; if you do something small in a loop the compiler will unroll it to 3 assignments or what not.

In addition, the reason that C programmers don't build their own abstractions is because C does not have templates. So building your own abstraction either means that it's not very abstract (i.e. restricted to one data type), or you are using void, or macros, or both. These things are all horrible to work with, void based data structures also involve a performance hit. This tilts the trade-off between writing abstraction and single-use code far, far towards the latter.

In C++ you have templates which are far better for writing your own data structure than macros, and have no performance penalty.

Re:The Resurgence of C Programming by Crespyl on Wednesday December 28, 2016 @04:43PM (#13273943)
You might be interested in Jai[0], Jonathan Blow's (as yet) unreleased language designed with game development in mind.

It's not strictly a subset of C++, but rather focuses on syntax and semantics that are convenient for the rapid development/exploratory refactoring and high performance that are characteristic of game dev.

Lots of tools for different kinds of manual memory management, build rules integrated into the source, syntax support for easily switching between "arrays of structs" and "structs of arrays" (and data-oriented types in general), simple static typing with type inference, that kind of thing.

[0] https://github.com/BSVino/JaiPrimer/blob/master/JaiPrimer.md

Re:The Resurgence of C Programming by pdimitar on Tuesday December 27, 2016 @05:37PM (#13266834)
Absolutely. I'd be delighted to code in a simplified C++.
Re:The Resurgence of C Programming by pcwalton on Wednesday December 28, 2016 @09:08AM (#13270512)
> In 20+ years of C, I've never had a (self-inflicted) problem in that area. Maybe I'm the rain man of bit-twiddling?

Have people been actively looking for mistakes in your code to find exploits?

I just wrote a simple throwaway .otf parser in C, which I've been coding in for a decade and a half. After trying to think about all the places overflow due to malicious input could occur, I just gave up and wrote "FIXME: Insecure" over it, pending a rewrite in something better.

In general, I don't see how you can deny that memory safety problems exist. Pwn2Own is a thing.

> What has caused me tremendous grief are all of the inconsistencies in the compilers, the gotchas of the precompiler, and the ambiguities in the language itself. C++ is even worse.

> Rust is great, but not great enough to justify a redo of a program that has been extended and maintained for decades (like vim or photoshop).

You just explained exactly why all those inconsistencies and ambiguities exist. And we will keep suffering from them as an industry until we decide to move beyond a language from 1978.

Re:The Resurgence of C Programming by jstewartmobile on Wednesday December 28, 2016 @10:13AM (#13270956)
Dude, I never denied that those problems exist, and I have no beef with your language.

My primary points are:

1. Memory management has never presented itself as public enemy #1 in my personal career. Other things have always been far more troublesome.

2. For complicated programs that have been continuously developed and extended for decades, a re-write in a "better" language is not a particularly good idea.

FWIW, for new stuff, Rust is a good choice.

Also, being at Mozilla, I can understand why memory management seems like priority #1. You are a platform!

The rest of us are building on the shifting sands that the west coast creates. Keeping up with Microsoft changing this and Google changing that is WAAAAY more trouble than pointer arithmetic (for me anyway).

Re:The Resurgence of C Programming by pcwalton on Wednesday December 28, 2016 @11:13AM (#13271423)
> 2. For complicated programs that have been continuously developed and extended for decades, a re-write in a "better" language is not a particularly good idea.

Can you explain the strategy you propose to stop the entire browser industry from getting knocked over at Pwn2Own every year?

Re:The Resurgence of C Programming by jstewartmobile on Wednesday December 28, 2016 @11:24AM (#13271526)
If Mozilla thinks it's a good trade-off to spend the next several years fighting functionality bugs in exchange for better pointer and memory guarantees with Firefox, they are more qualified to make that call than I am.

For other types of program that I am familiar with, that is a raw deal. Take vim. I don't have it exposed on the network. I've never had any problems with it. It does not affect me in the slightest if the guys at a Pwn2Own can contrive some convoluted attack against it. The functionality is more important than the security is for my usage case. I would rather it just keep working than have it be undefeated at Pwn2Own.

Re:The Resurgence of C Programming by pcwalton on Wednesday December 28, 2016 @01:34PM (#13272512)
At this point I think you're making an argument about software evolution more than programming languages. "Just keeping it working" is fine for software like Vim, which has a natural monopoly on the small niche of longtime programmers who have memorized the keystrokes and like it the way it is. (I am not insulting Vim users: I am one of them!) It does not work for software like browsers in a deeply competitive market, which have to cater to a large audience of hundreds of millions who constantly demand increased stability, security, and performance.
Re:The Resurgence of C Programming by jstewartmobile on Wednesday December 28, 2016 @01:47PM (#13272605)
This thread has gotten so unwieldy that I now have more arguments than I started with! ;-) But yeah, evolution over revolution.

Perhaps that could be a fun challenge. Take some creaky old thing, have team A re-do it in Rust, have team B do an OpenBSD-style hackathon on it in its native language, let the QA guys and the hackers loose on it, and see which one fares better.

Re:The Resurgence of C Programming by stymaar on Tuesday December 27, 2016 @04:57PM (#13266544)
> Rust is great, but not great enough to justify a redo of a program that has been extended and maintained for decades (like vim or photoshop).

I agree with that, and most people do even in the Rust community. I don't expect people to rewrite their software in Rust, but if people could stop writing new C code[1], the world would become a better place in the next decades …

> Whenever C gets brought up, people are like, "pointers... memory... dangerous!" In 20+ years of C, I've never had a (self-inflicted) problem in that area.

In 20+ years of C, you never faced a single segfault ?! I'm sorry but I don't trust you. You're basically pretending being the One True God of programming.

[1]: even in a full C project, it's straightforward to write you new code in Rust in separate files, thanks to Rust really good interop with C. Example: https://bawk.space/2016/10/06/c-to-rust.html

Re:The Resurgence of C Programming by ArkyBeagle on Tuesday December 27, 2016 @06:36PM (#13267253)
It's just not that difficult to avoid segfaults, signed integer overflow, all the usual Mr. Hyde aspects of C.

There's nothing godlike about it - it's just practice. He's been using C for 20+ years. So that's probably 10+ years of very little or no Bad UB Voodoo.

Re:The Resurgence of C Programming by kbenson on Tuesday December 27, 2016 @08:48PM (#13267841)
> He's been using C for 20+ years. So that's probably 10+ years of very little or no Bad UB Voodoo.

The implication being that it takes nearly 10 years of C programming experience to get to the point where there's very little or no bad UB voodoo?

I guess as long as we only let 10-year veterans of C write programs in it, we're fine then. We can solve how to deal with the fact nobody else if getting experience in C anymore because they aren't allowed to write in C later...

Re:The Resurgence of C Programming by ArkyBeagle on Tuesday December 27, 2016 @09:11PM (#13267923)
I meant very probably. Surely it takes less than that.
Re:The Resurgence of C Programming by kbenson on Tuesday December 27, 2016 @09:29PM (#13267985)
Sure, but 10 years is a large enough time that "less than that" can be half, it it's still rather long. There's something to be said for languages that change the effects of poor choices from security problems and inefficiencies to mostly just inefficiencies. Nobody is born knowing how to program, so all programmers have to go through a phase where they don't have the knowledge or experience to make the correct choice in every situation. Every language will have some percentage of its user base subject to this more or less.

Another way to think of it is herd immunity. The more we can gently guide and gently admonish these nascent programmers for doing things that are probably a bad idea, the more we can protect everyone else, the public and other programmers alike, from most their bad choices until they've learned when it's appropriate to break those rules.

Re:The Resurgence of C Programming by jstewartmobile on Tuesday December 27, 2016 @05:24PM (#13266729)
My claim is that the particular class of bugs relating to memory/overflows have not been an issue in my career, while bugs arising from API and language ambiguities have caused considerable headaches.
Re:The Resurgence of C Programming by emmelaich on Tuesday December 27, 2016 @07:42PM (#13267563)
The problems caused by language ambiguities and pointer arithmetic and addressing is exactly what makes C difficult.

So, I don't disbelieve you but I've known 20 year C experts have their WTF moments when shown code that would seem to work but doesn't.

But I agree that C difficulty is sometimes exaggerated - partly it's expectations.

ps. by ambiguity do you mean undefined behaviour?

Re:The Resurgence of C Programming by thegeekpirate on Tuesday December 27, 2016 @10:10PM (#13268154)
> So, I don't disbelieve you but I've known 20 year C experts have their WTF moments when shown code that would seem to work but doesn't.

If after 20 years they don't know the C spec well enough to know if a piece of code should work or not, I simply wouldn't consider them very good programmers.

Re:The Resurgence of C Programming by emmelaich on Tuesday December 27, 2016 @11:08PM (#13268359)
Hrrm.

If Jon Bentley can have a bug in his Programming Pearl book then so can anyone.

https://research.googleblog.com/2006/06/extra-extra-read-all...

Re:The Resurgence of C Programming by thegeekpirate on Wednesday December 28, 2016 @12:28AM (#13268638)
I never said they wouldn't create bugs, but not fully understanding a line of code (outside of needing to conceptualize external dependencies) is certainly frightening after 20 years of working in C.
Re:The Resurgence of C Programming by ktRolster on Wednesday December 28, 2016 @04:55AM (#13269567)
What it shows is that sort of code never shows up in practical C. There's stuff in Java (and Javascript for that matter) I don't understand, and I've been programming in those for about as long as anybody.
Re:The Resurgence of C Programming by thegeekpirate on Tuesday January 10, 2017 @08:57PM (#13371138)
Absolutely.
Re:The Resurgence of C Programming by Keyframe on Tuesday December 27, 2016 @03:04PM (#13265792)

    Whenever C gets brought up, people are like, "pointers... memory... dangerous!"
That's actually the point. It's even coded into C2x charter ( http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2086.htm ):

    The new spirit of C can be summarized in phrases like:

        (a) Trust the programmer.
        (b) Don't prevent the programmer from doing what needs to be done.
        (c) Keep the language small and simple.
        (d) Provide only one way to do an operation.
        (e) Make it fast, even if it is not guaranteed to be portable.
        (f) Make support for safety and security demonstrable.
Re:The Resurgence of C Programming by bitwize on Wednesday December 28, 2016 @09:20AM (#13270593)
That's the thing; programmers are NOT TRUSTWORTHY. This is a "humans are fallible" thing, not a "you can't trust stupid programmers" thing.

This is why C and Unix are irredeemably flawed designs; they trust the individual programmer/sysadmin to get things right and disaster happens when they don't. In the case of Unix, it can be demolished with a single fat-fingered rm command as root. VMS made a different call: in VMS it is assumed that the sysadmin is tired and hasn't had their coffee. This affects everything from how permissions are assigned to the notorious verbosity -- and extensive help system -- of the VMS shell. Properly configured, VMS was darn-near impregnable; it had also never fallen to the sort of buffer vulnerability common under Unix.

Re:The Resurgence of C Programming by hash-set on Wednesday December 28, 2016 @09:38AM (#13270717)
Too bad the business model of VMS was so bad, eh? UNIX, and more to the point, KILLED VMS on every front. And yes, I have had the displeasure of having to use VMS and code in it and deal with the special snowflake sysadmin people who operate VMS, the most recent one being just two years ago. What a time! What mystifies me is that there are still many companies out there who refuse (stuck?) to migrate off of ancient OpenVMS Alpha hardware--all because the IT people stomp their feet and throw tantrums and won't let it go. Where are the rational tech people? Still advocating these monoliths for job security...

VMS had its day, its day is over. Learn. New. Skills.

I enjoyed using VMS in college years ago. I am now biased because I have never been mistreated as a professional developer so badly than while dealing with that VMS admin! The man was so toxic that the company should have fired him many times over but refused because he was the "only" one who could kinda sorta run their database (note: they had to restart the application daily to keep it running and the boxes had all kinds of memory issues and they were buying used hardware off of eBay to keep it running--this is a major healthcare company mind you, thousands of customers whose lives are at stake).

Time marches on, skillsets have to be upgraded, which is apparently too much for some people to accept.

Dumb companies, dumb sysadmins.

Re:The Resurgence of C Programming by loup-vaillant on Tuesday December 27, 2016 @03:30PM (#13265948)
(f) Does this mean they'll remove some undefined behaviour? Or at least mandates options to that effect? That would be marvellous.
Re:The Resurgence of C Programming by wangchow on Tuesday December 27, 2016 @03:46PM (#13266037)
I tend to read undefined as don't do it
Re:The Resurgence of C Programming by syncsynchalt on Tuesday December 27, 2016 @08:53PM (#13267862)
It's not always possible / feasible to avoid undefined operations.

Use the modulo operator? Undefined unless you checked for negative first.

Add two integers? Undefined unless you check for overflow.

Granted those examples get a pass because on modern two-complement architectures everything handles the undefined behavior in an identical way.

Re:The Resurgence of C Programming by loup-vaillant on Wednesday December 28, 2016 @04:53AM (#13269560)
I believe the modulo operator is implementation defined. As should be signed integer overflow, though it isn't.

One big problem about "undefined" is, when some platform go bananas over some stuff, the behaviour is standardised as undefined for all platforms, allowing the compilers to go bananas. Which they do, because every bit of undefined helps them perform some micro-optimization they couldn't do before.

I long for the day where the standard forces compilers to provide options such as -fwrap or -fno-strict on platforms that can reasonably support it.

Re:The Resurgence of C Programming by nickpsecurity on Tuesday December 27, 2016 @05:22PM (#13266717)
That's Modula-2. Maybe they just need to change the syntax a bit to look more like C, built an IDE plugin, and reboot the Modula-2-to-C compiler to leverage optimizing compilers.

From the reboot one group is doing:

http://modula-2.info/m2r10/pmwiki.php/Spec/DesignPrinciples

Re:The Resurgence of C Programming by dTal on Wednesday December 28, 2016 @08:05PM (#13275004)
Seems to me (b) and (d) are mutually exclusive, as are (a) and (f).
Re:The Resurgence of C Programming by faragon on Tuesday December 27, 2016 @02:27PM (#13265484)
Also, there is the risk of re-doing everything and getting worse results: e.g. executable/library bloat, code harder to read/understand, interoperability/binding issues, etc.
Re:The Resurgence of C Programming by k__ on Tuesday December 27, 2016 @02:29PM (#13265518)
At least Rust allows to write drop-in replacements.
Re:The Resurgence of C Programming by faragon on Tuesday December 27, 2016 @03:09PM (#13265813)
Theoretically, yes. In practice, you'll get "Frankensteins" with multi-platform compatibility issues.
Re:The Resurgence of C Programming by willtim on Tuesday December 27, 2016 @03:17PM (#13265868)
From a security perspective, C is inadequate. This is the biggest issue facing our use of the language currently.
Re:The Resurgence of C Programming by jstewartmobile on Tuesday December 27, 2016 @03:27PM (#13265932)
From a security perspective, if you think C is inadequate, try taking a look at the instruction set docs for one of Intel or AMD's semi-modern chips. ;-)
Re:The Resurgence of C Programming by nickpsecurity on Tuesday December 27, 2016 @05:24PM (#13266736)
Cornell did that. They saw horrible things. Then, they fixed the root cause:

https://www.cs.cornell.edu/talc/

Did something similar with C in Popcorn: a safe, C dialect that compiles to TALC. Gotta wonder what things would be like if more groups took such an approach to the problems they've found in C, UNIX, etc. Well, it was a nice vision at least. :)

Re:The Resurgence of C Programming by emmelaich on Tuesday December 27, 2016 @10:14PM (#13268176)
I followed the web search links to Cyclone, Popcorn's successor and ended up at http://www.eecs.harvard.edu/~greg/cyclone/ which is a 404.

Which suggests how popular these safe C's are, regrettably.

Re:The Resurgence of C Programming by nickpsecurity on Tuesday December 27, 2016 @10:57PM (#13268326)
Yep. How it always goes. Fortunately, Cyclones region and dynamic safety helped inspire Rust's scheme. It went somewhere even if not for C programmers in general. Far as also-rans, there's Microsoft's Vault, FLINT's C0 used in Verisoft for whole-system verification, and Clay that's mainly applied by Lea Wittie in stuff like device drivers.

https://web.archive.org/web/20080219014100/http://research.m...

http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.468...

http://www.verisoft.de/VerisoftRepository.html

http://www.eg.bucknell.edu/~lwittie/research/Clay.pdf

http://www.eg.bucknell.edu/~lwittie/research.html

Re:The Resurgence of C Programming by yxhuvud on Tuesday December 27, 2016 @03:38PM (#13265989)
That is not an excuse. Defence in depth is a thing.
Re:The Resurgence of C Programming by jstewartmobile on Tuesday December 27, 2016 @03:46PM (#13266033)
If you're building on a sinkhole, I don't see how having really nice floors helps.
Re:The Resurgence of C Programming by platz on Tuesday December 27, 2016 @04:13PM (#13266218)
I don't see how the chip's 'sinkhole' enabled bugs like heartbleed, which was industry-scale, which absolutely could've been prevented by having a really nice floor.
Re:The Resurgence of C Programming by jstewartmobile on Tuesday December 27, 2016 @04:20PM (#13266284)
You can fix heartbleed--even in C. You can't fix TPM hacks, rowhammer, etc. without buying a new machine.

That's not even getting into the potential of the missteps in the RMM / MMU / SMP / virt systems that exasperate even Torvalds and deRaadt.

Re:The Resurgence of C Programming by sitkack on Tuesday December 27, 2016 @05:15PM (#13266677)
You are making an all or none fallacy. While those things do exist, we can't use them as an excuse to prevent the common case.
Re:The Resurgence of C Programming by jstewartmobile on Tuesday December 27, 2016 @05:33PM (#13266803)
I'm not making any kind of fallacy here. The chipset is the foundation. Even with perfect programs written in perfect languages, the Mossad can still get whatever they want without breaking a sweat thanks to the silicon.

If we were going to set priorities for making things "better," the foundation would be the reasonable place to start. We'd probably be happy with Algol if we were running it on B5000-style hardware.

Re:The Resurgence of C Programming by joncampbelldev on Tuesday December 27, 2016 @06:15PM (#13267114)
It sounds like you mean that stopping the vast numbers of lesser attackers other than Mossad is so much less important that its worth ignoring.

Most people's day to day experience of vulnerabilities is someone getting access to their password or (for the techies) their private server. Stupid actions aside (like leaving a database open to the internet), it'd be nice if things like heartbleed weren't so prolific.

Perhaps when we're living in a dystopian facist state we will wish we started out by fixing the hardware vulns, but until then it'd be nice if, for example, a person who has setup ssl correctly can assume it won't leak data all over the place.

Re:The Resurgence of C Programming by jstewartmobile on Tuesday December 27, 2016 @07:05PM (#13267405)
Never said to ignore anything. I'm just outlining priorities.

With things like rowhammer, you don't have to be Mossad to exploit it, and you can't apt-get or windows update your way around it.

From your own examples, better languages can only do so much.

Re:The Resurgence of C Programming by MaulingMonkey on Tuesday December 27, 2016 @04:32PM (#13266378)
No point in building elsewhere if any earthquake will cause the structure to collapse, killing everyone inside, even on more solid ground.

I'd love for chip design to be the weak point for once. Let's make it happen.

Re:The Resurgence of C Programming by emmelaich on Tuesday December 27, 2016 @07:45PM (#13267578)
From a speed and control perspective, nothing else is adequate.

The best we can hope for in the medium term (20 years?) is to have C as a target / intermediate / escape (ie. FFI) language.

Re:The Resurgence of C Programming by Annatar on Tuesday December 27, 2016 @03:38PM (#13265988)
From a security perspective, C is inadequate.

The implication here being that Rust is adequate, I take it? Let us not circle around the issue!

You could assert the same for assembler, and yet, assembler is the ultimate programming - the last stop: highest performance, maximum control, no safety. When then, was the last time you heard or read someone claiming that "assembler is inadequate", especially when it comes to security?

I could think of no language more adequate to push the electronics to their limit, and beyond, as Commodore 64 teaches us over and over again, even in 2016.

All I want to say is that your argument rings hollow. Yes, C has no safety. If my code has a hole, it will be noone's fault but my own. And that's the way I like it: it is far more preferable to an ultracomplex programming language like Rust.

And finally, a Zen koan: I was troubleshooting some code today, which I wrote in AWK. Now the code transformed the data exactly as I had coded it, and the code was 100% correct, the transformed data was exactly as expected, yet no output was coming out.

Everything which was in the program was 100% correct. The problem wasn't in that which was in the program, but that which was not: there was no clause to output the transformed data. There is enlightment to be had from this tale, specifically about security, and even more specifically about Rust the programming language and its compiler.

Re:The Resurgence of C Programming by MaulingMonkey on Tuesday December 27, 2016 @04:54PM (#13266520)
> The implication here being that Rust is adequate, I take it?

I think the implication here being that Rust is an improvement. Perhaps not even Rust is adequate, depending on one's needs, but it is at least a step in the right direction.

> Yes, C has no safety. If my code has a hole, it will be noone's fault but my own. And that's the way I like it

This is the way you and so many other C programmers "like it". As a result, buffer overflows, use after free bugs, and other completely understood reoccurring bugs continue to plague the CVE database in the form of new RCE vulnerabilities.

Maybe you're the promised child, the next Buddha, who will usher in a new age of secure C.

> I was troubleshooting some code today

Oh, you're a mere mortal like the rest of us.

Look, I get it, you don't want to give up the "power" of C for the improved memory safety of something else you don't yet understand. But you could really simplify your argument to: "I don't care much about safety, so C is fine." And, hey, you know, that's actually a legitimate argument.

I care about safety. I recognize I am mortal, so I have my code reviewed for mistakes. I recognize my reviewers are mortal, so I apply static analysis, unit tests, fuzz testing, and integration tests to catch the mistakes my reviewers won't. Even these are fallible, so I apply all the latest and greatest mitigation that I can - ASLR, stack cookies, W^X, the works.

If there's a hole, it will be the "fault" of me, my coworkers, the authors of the tools we use, and so many more. This is a step in the right direction - towards how just how I like it. Where one mortal may fall, perhaps a team of them shall succeed.

And yet it's still not enough.

Re:The Resurgence of C Programming by Annatar on Wednesday December 28, 2016 @02:41AM (#13269066)
Look, I get it, you don't want to give up the "power" of C for the improved memory safety of something else you don't yet understand.

Not quite: I am vehemently against the idea of trading simplicity of C for ultra complexity of Rust, just so I could get some compile time checking, and I will forever be the enemy of that idea.

But you could really simplify your argument to: "I don't care much about safety, so C is fine."

I care very much about safety. But I will not trade simplicity for an ultra complex language like Rust, just so the compiler could do some compile time checking.

Oh, you're a mere mortal like the rest of us.

Buddha was a mere mortal too. However, this programming business is special to me. Computers aren't only my passion. They're my life.

Maybe you're the promised child, the next Buddha, who will usher in a new age of secure C.

And just like all the 33 buddhas, I too am straining and struggling to become one, even if it takes 100,000 years.

Re:The Resurgence of C Programming by MaulingMonkey on Wednesday December 28, 2016 @06:49PM (#13274686)
> Not quite: I am vehemently against the idea of trading simplicity of C for ultra complexity of Rust

The intricacies of undefined behavior escape a lot of my coworkers. Having to painstakingly explain strict aliasing rules and what constitutes a sequence point (or doesn't) isn't "simple". Even basic multithreading support as recently as C99 required third party libraries, and compiler extensions - if only to prevent the unexpected reordering of code by the optimizer.

In practice, this is complex enough that I resort to third party tools to try and manage these and other complexities in the form of static analysis, aided by even more compiler extensions. I retrofit them to existing code, and then it points out where shared data is accessed without being protected by locking the appropriate mutex - and then I smile, for I've seen weeks sunk debugging such bugs, and I've spent 10 minutes to not only catch one such bug, and prevent them in the future for this code. Iterator invalidation checks? Sign me up!

Rust's lifetime management and borrow checking are, frankly, a much more comprehensive and unified way of doing a lot of what I was already doing in C and C++ code. We end up disagreeing on which language is the simple one, and which language is the complex one.

> I care very much about safety. But I will not trade simplicity for an ultra complex language like Rust, just so the compiler could do some compile time checking.

Do your actions agree with your words? I've listed several of the things I've done to wrangle with the problem of safety - not a comprehensive list, mind you, but a good start. Perhaps you go even further, and use one of the "safe" C subsets such as MISRA C?

EDIT:

> Yes, C has no safety. If my code has a hole, it will be noone's fault but my own. And that's the way I like it: [...]

Are you sure you care very much about safety?

Re:The Resurgence of C Programming by Annatar on Thursday December 29, 2016 @01:33AM (#13276003)
Rust's lifetime management and borrow checking are, frankly, a much more comprehensive and unified way of doing a lot of what I was already doing in C and C++ code. We end up disagreeing on which language is the simple one, and which language is the complex one.

Yes, we disagree, and vehemently at that. I think borrowing is one of the most overcomplicated things in Rust, and is one of the major reasons why I am against it. You hit the nail on the head.

Are you sure you care very much about safety?

Yes. Every piece of code I write in C, when I write it in C, is run through a debugger before it is put in production, because I don't trust my code and I don't trust myself. In fact, I don't release anything in any programming language without having debugged it first, even when it appears to function correctly. It's still simpler than Rust!

Re:The Resurgence of C Programming by naasking on Tuesday December 27, 2016 @04:19PM (#13266271)
> When then, was the last time you heard or read someone claiming that "assembler is inadequate", especially when it comes to security?

All the time. Virtually no one would recommend writing any serious software in assembler. The only software written in assembler is high performance numerical code and certain hardware-specific kernel device drivers.

> If my code has a hole, it will be noone's fault but my own.

And who's going to hold you accountable for that hole that just leaked 100,000 credit card numbers? No one, that's who. The institutional bias against safety and the insulation programmers enjoy from the consequences of their code are the only reason attitudes like yours persist, and the trivial security bugs that inevitably follow.

> And that's the way I like it: it is far more preferable to an ultracomplex programming language like Rust.

Rust the language is not ultracomplex. Don't confuse the language with the compiler.

Re:The Resurgence of C Programming by stymaar on Tuesday December 27, 2016 @05:14PM (#13266669)
> The only software written in assembler is high performance numerical code and certain hardware-specific kernel device drivers.

Don't forget the cryptographic primitives : coding them directly in asm is the only way (at least the only way I know) to be sure that the execution will be done in constant time to avoid «timing attacks».

Re:The Resurgence of C Programming by naasking on Tuesday December 27, 2016 @10:32PM (#13268240)
Re:The Resurgence of C Programming by pekk on Tuesday December 27, 2016 @04:31PM (#13266376)
If you want individual programmers to be "held accountable" for bugs they write, it seems that you do not consider their employers or managers even to be involved. This is an overly-simplistic understanding of where bugs come from.

Your argument depends on the premise that Rust is necessarily better than (say) C. If it turns out that Rust has a bug in it (it's software, it should have bugs, and it's relatively new software as well), then should the programmer who chose it over something else be liable? What if the alternative were an extremely rigid discipline for C programming using a very mature toolchain? I suspect your evidence for Rust being safer isn't worth taking to court.

Thought experiment: if an Evil Dictator simply killed programmers for writing software that contained bugs, would it give rise to a race of perfect programmers? Or would it crush the industry and impair the economy? Would you stake your life on Rust being bug-free? But you can financially ruin almost any engineer for life with the value of a suit for 100,000 credit card numbers. Under that regime, engineers who assumed all the risk would reasonably expect a much larger share of the profits. Are you starting to understand why programmers are not held individually liable for every bug they write?

Re:The Resurgence of C Programming by SpaceManiac on Tuesday December 27, 2016 @07:27PM (#13267505)
Maybe I read it differently, but it seems to me that GP us more concerned with the institutional bias and the attitude rather than anything relating to legal liability... the programmer is allowed to get away with believing that they are taking responsibility for the security of their code, but never feels any consequences for failure, and thus believes they are doing a good job when they are not.
Re:The Resurgence of C Programming by naasking on Wednesday December 28, 2016 @12:09AM (#13268554)
That's phrasing it better than my original rushed comment, thanks. This insular environment doesn't tend to incentivise responsible choices in software development or in deployment.

Perhaps liability is one way to address it, but hardly the only way. "Engineer" here in Canada is a protected term and you must belong to the society of professional engineers (P.eng), which carries various legal responsibilities when signing off on work.

Requiring code reviews by a P.eng creates a whole different set of incentives, which would emphasise languages that are more expressive, clearer and easier to audit because the P.eng's time is way more costly than the whining of a software developer that wants to squeak 1% more performance out of his inner loops.

Re:The Resurgence of C Programming by bitwize on Wednesday December 28, 2016 @09:28AM (#13270653)
Individual engineers are held accountable -- sometimes criminally -- for bridges they design. Why shouldn't we do the same for programmers -- make it a licensed and bonded profession with serious consequences for screwing up? It could go a long way towards cleaning up the crappy practices which are accepted as normal for the field. Silicon Valley techie culture has long afforded programmers too much freedom. They serve the public and should be held accountable to the public.
Re:The Resurgence of C Programming by naasking on Wednesday December 28, 2016 @12:24AM (#13268625)
> If you want individual programmers to be "held accountable" for bugs they write, it seems that you do not consider their employers or managers even to be involved. This is an overly-simplistic understanding of where bugs come from.

It's not overly simplistic to point out that at least 80% of security vulnerabilities would never have happened if the program had been written in a memory safe language. That's not a management problem, that's an institutionalised programmer bias.

And my argument does not depend on Rust at all. Plenty of safer alternatives to C exist, like Ada, or heck, Frama-C verification of C code. These tools aren't well known or sufficiently funded because of your exact type of bias that there's nothing wrong with choosing C.

Re:The Resurgence of C Programming by nickpsecurity on Tuesday December 27, 2016 @04:36PM (#13266402)
"assembler is the ultimate programming - the last stop: highest performance, maximum control, no safety. "

Nah, that's microcoding, synthesis of control/data paths in NISC, or use of FPGA's. Assembly is for people that can't handle doing a custom ASIC on their own. ;)

https://en.wikipedia.org/wiki/No_instruction_set_computing

Re:The Resurgence of C Programming by Roboprog on Wednesday December 28, 2016 @12:01PM (#13271800)
And now some guy's about to poke y'all with a soldering iron (etc)... :-)
Re:The Resurgence of C Programming by geofft on Tuesday December 27, 2016 @04:23PM (#13266308)
> When then, was the last time you heard or read someone claiming that "assembler is inadequate", especially when it comes to security?

Get some drinks with OpenSSL (or BoringSSL or LibreSSL) hackers and ask them how they feel about perlasm.

> If my code has a hole, it will be noone's fault but my own.

If you're a one-person development team, you're not talking about the same scale of development the rest of this thread is about.

Re:The Resurgence of C Programming by pdimitar on Tuesday December 27, 2016 @03:02PM (#13265771)
IMO it's yes and no.

YES: Because you're right. Small more iterative changes in terms of tightening up the language to allow for more predictable software (and environment like the kernel) can get us a long way ahead.

NO: Because even though you're very correct, there comes a point in any software stack where the expenses of rewriting the whole thing are vastly smaller than the expenses of iteratively reworking it.

I have drifted away from C/C++ a long time ago -- around 10 years. I personally got sick and tired of per-compiler quirks, different precompiler policies, and writing sed scripts to fix messed up preprocessed files, to name only 3 generic problems.

IMO I believe if something between Golang and Rust comes along and brings only their positives to the table, it'll be very worth to rewrite (or make richer version of) a huge amount of legacy tools in them -- especially if they bring extremely easy cross-compiling and strong runtime guarantees.

I don't know enough to claim either way but in my eyes C has been around for a very long time and a good chunk of the complaints are still in place. I'm tempted to think the community had its chance and that it's time something [somewhat] better must replace it.

Re:The Resurgence of C Programming by jstewartmobile on Tuesday December 27, 2016 @03:09PM (#13265811)
In the commercial space, devs already have to rework their apps frequently to handle the curve-balls MS/Apple/Google etc. throw at them. If we had a C compiler with webkit-level dominance, and we made just one fix to it every cycle, that would be a big thing, and it would be manageable!

It's like, "Oh, to be C-2016 compliant I've got to get rid of all my calls to unsafe string functions." Search, replace, and some elbow-grease later, and I've improved my program with a much lower likelihood of breaking functionality.

Re:The Resurgence of C Programming by stymaar on Tuesday December 27, 2016 @05:23PM (#13266725)
> devs already have to rework their apps frequently to handle the curve-balls MS/Apple/Google etc. throw at them. If we had a C compiler with webkit-level dominance, and we made just one fix to it every cycle, that would be a big thing, and it would be manageable! It's like, "Oh, to be C-2016 compliant […]

Fortunately, the web doesn't work the way you think it work ! JavaScript written in 2005 is still working nowadays, and «not breaking the web» is the main reason JavaScript is so quirky. And the backward compatibility story of Microsoft Windows over the last 30 years is one of its bigger success.

You can't just expect people to rewrite their whole code every now and then … And if you do, people just stop updating or even drop your platform.

Re:The Resurgence of C Programming by jstewartmobile on Tuesday December 27, 2016 @05:41PM (#13266868)
Both Windows and JavaScript do break things, regularly. Small stuff, but stuff, and worst of all, it is usually in the service of some internecine pissing-contest instead of an incremental approach towards "better."

If we did the same thing with C, but with more high-minded goals, it would be a fine investment in the future.

Re:The Resurgence of C Programming by pdimitar on Tuesday December 27, 2016 @03:23PM (#13265909)
Since I am no longer heavily invested in the C/C++ stack I have no choice but to agree with you.

My general point is that IMO the tech giants' patience towards C's persistent problems is long over and that's why we have Golang, Swift, Rust etc. Don't crucify me for the "persistent problems" thing please. ;)

I fully understand the need for a language as close to the bare metal hardware as possible but many people -- me included -- prefer a more stable and predictable environment with the price of less speed.

I believe there's no right or wrong side in this particular preference.

Re:The Resurgence of C Programming by sbov on Tuesday December 27, 2016 @03:22PM (#13265902)
How do you define problem? In terms of consequences or mere presence of a bug? If it's consequences, is it plausible that you have had no problems because not enough people are interested in attacking your code? If you say you have never produced a memory/pointer related bug that got past you, then you probably are the rain man.
Re:The Resurgence of C Programming by jstewartmobile on Tuesday December 27, 2016 @03:41PM (#13266005)
I mean that through strict valgrind and fuzzers, I've never had it find anything in my own code. I've also never had a hard-crash from anything in my own code. I attribute this to personal paranoia about input and indices.

Worst experiences I've had in that domain were due to inconsistencies in things like the Win32 API across different OS versions that were allegedly supposed to behave the same way.

Sometimes I think better API and language documentation would improve programs more than better languages.

Re:The Resurgence of C Programming by geofft on Tuesday December 27, 2016 @04:20PM (#13266278)
Wouldn't you prefer to have the computer deal with the personal paranoia for you?

I love C dearly, but I can write so much faster in, say, Python, and that code is usually production-suitable. If I say "for line in open(sys.argv[1])", I don't have to spend 50 lines dealing with open() failing, or sys.argv() being the wrong length, or allocating a buffer to read into and recombining lines longer than the buffer, or whatever. Ideally in Python I'd print better error messages, but it's fine if I forget; Python will take care of each of those problems and do something safe, if not user-friendly. If I forget any of those in C, it's emphatically not fine.

Rust - and many other higher-level compiled languages! - promise to bring that development speed and confidence back to the domains where C dominates.

Re:The Resurgence of C Programming by jstewartmobile on Tuesday December 27, 2016 @04:28PM (#13266352)
I do prefer it, and for new things, I love Rust and Golang and Clojure. I even kind-of like Python (aside from the blocks-by-indentation thing).

I'm just saying that for old things, staying the course will probably be more fruitful than fresh start in a different language.

Re:The Resurgence of C Programming by kbenson on Tuesday December 27, 2016 @09:07PM (#13267907)
That's why the spurred interest in C and C++ in providing more safety mechanisms, which I believe is because of the increased competition in this realm from Rust, is a good thing. If we can get most the way to what Rust provides in C and C++ through tooling and extensions, there's a path for existing source that can't or shouldn't be rewritten, and new projects get to make a choice of what they want to use.
Re:The Resurgence of C Programming by Manishearth on Wednesday December 28, 2016 @01:49PM (#13272625)
I believe that most of the C++ safety stuff happened independently of Rust existing. A lot of it started before Rust was a big thing.
Re:The Resurgence of C Programming by kbenson on Wednesday December 28, 2016 @02:02PM (#13272730)
Sure, but I would argue that there's much more interest in it now that there's a credible alternative that does care about it. That is, it existed, and people used it, but now people might feel a little bit of a need to justify why they are using C or C++ when then didn't before, and so their confirmation bias might cause them to look more into those existing safety mechanisms, and maybe even use them.

Put another way, even if Rust were to disappear tomorrow, I think the net impact would have been very positive in that it exposed people to these concepts in a concrete way they weren't before, because they are optional in the C and C++ ecosystem.

Re:The Resurgence of C Programming by maxxxxx on Wednesday December 28, 2016 @09:12AM (#13270539)
I have seen memory errors in large C codebases produced by larger teams. I think C requires a certain level of discipline and a lot people working at large companies simply don't care enough.

From my experience using a simple subset of C++ using things like shared_ptr reduces problems a lot.

Re:The Resurgence of C Programming by Volt on Tuesday December 27, 2016 @07:49PM (#13267595)
>I've never had a (self-inflicted) problem in that area.

That you know of.

Re:The Resurgence of C Programming by pjc50 on Tuesday December 27, 2016 @05:24PM (#13266737)
"(Self-inflicted)" is an important disclaimer, because it implies that you work mostly on your own from the metal up?

(Also a meta-note about HN discussion: we have years of people saying "there's a problem here" and one guy saying "it's not a problem for me", seemingly unable to see why anyone else has a problem. "Works for me" is not a mission statement.)

Re:The Resurgence of C Programming by jstewartmobile on Tuesday December 27, 2016 @05:27PM (#13266756)
Nah. I have had to deal with memory issues in 3rd-party dependencies, so I'm not saying it never happens. I'm just saying I have much bigger problems in other areas that are mostly unaffected by "better" languages.