There have been a few attempts to make C safer. However, one of the most popular aspects of C is the fact that it works everywhere. That means vendors are expected to have a working compiler for their platform. The easiest way to do that is to keep C features minimal. C99 was controversial because it asked these vendors to comply with changes in the language. C11 actually reduced many of the requirements in C99, making them optional. Sometimes this can be frustrating for programmers. Luckily clang-tidy and various sanitizers or valgrind can catch many issues you will encounter writing C.
To understand the story a little more regarding Backpage and its criminal activities, I'd highly recommend watching "I am Jane Doe" on Netflix. It is a documentary exposing the child prostitution and human trafficking Backdoor facilitated.
I've been at two major companies and both used some form of Wiki or collaborative site. If any company had a good idea how to do this, everyone would be doing it that way by now. There are definitely still improvements that need to be made to existing platforms. For example, neither site had a great search engine.
I'm pretty sure you are talking about a different point. The original comment is about laying out all the arguments upfront to avoid the appearance of back peddling if the first argument turns out to be false. You seem to be focusing on the example more than this point.
On Mac, I find lldb is terribly low level. IIRC Linux gcc isn't great either. Even delve will frequently seem to have missing/optimized variables that cannot be printed.
People generally don't want a new license or a modified license. In my experience, software licenses at big organizations are a bereaucratic nightmare. Often, you just want something on the pre-approved list.
I'm not sure how easy Rust claims to be... The main idea here is " I love that Haskell-esque feeling where a compiling program is usually a working program." Rust will probably get easier, but it's main goal is safety.
The main problem I have with a pure safety focus is that the warnings often feel like overkill for 99% of programs. For example, when gcc yells about comparing signed and unsigned ints, I find that there rarely is a true safety concern involved. I hope Rust is better than that.
If you search "Uber autonomous vehicle" you can see some videos of the display. From what I gather, basically gathers the signals into a human readable model. In general I wouldn't have recommended this driving style but it might have been too dark to see much anyway.
I am pretty sure Uber uses an iPad app for its autonomous vehicles. The driver is looking at that iPad application periodically along with the physical windshield view.
I think you might be confusing "defensively" with perfectly. There are situations even defensive driving cannot prevent. For example, any car going 35 mph will need a few feet to brake if something jumps directly in front of it. Defensive driving just accounts for one's surroundings and likely outcomes. Seeing as the cars have been on the road in Arizona for a while, and this is the first we are hearing about a pedestrian collision, it seems the algorithm is pretty safe.
Actually even the use of embedded here is somewhat ambiguous. Embedded as in devices, or embedded as in embedded within another programming language. I think it might mean the latter here.
Not sure what is political. I consider Wikipedia and SO to be perfect democracies of information. People upvote answers they consider correct. Those who contribute good answers frequently have demonstrated their skills and knowledge. If another talented contributor provides intelligent answers, we would happily upvote his or her answers as well.
I'm a Jaeger developer at Uber, so this could be a bit biased. Jaeger is the only major open source distributed tracer I know of that conforms to the OpenTracing standard. OpenCensus and presumably Canopy require tracer-specific code to be embedded in your program. This makes you locked in to a given provider. You won't find many people who have tested them side by side. Jaeger follows the OpenTracing standard so you can embed generic tracer code and change your tracer on the fly. Once you do this, comparison testing is easy.
I think Fortran uses a number followed by a byte array to represent strings. This is the big argument with C which used null terminators. In retrospect, maybe Fortran was right after all.
Edit: Actually seems I confused Fortran and Pascal. Also, Fortran uses an internal length variable.
I'd choose Go. Has long-term support from Google. Generally easy to learn. Many less bugs in my experience than Python. Don't know enough about Haskell to comment.
That's an interesting insight. I think the reason has less to do with the languages being good for language development than it is about other language features. JavaScript is the Internet's only frontend language. For many C/C++ programs, users may write plug-ins only in Lua. The common aspect is that the users are forced into choosing the language for external reasons. Many of them see flaws in JavaScript and/or Lua and would like to write in another language instead. That's how I see transpilers coming into existence for these languages.
I completely disagree. I felt it was a modern followup to the classic Design Patterns (Gang of Four) book. The author is not trying to teach game programming as much as he is demonstrating how they are practical in his line of work.
My biggest question would be what modern means to you? Does it mean the style of the newest popular C project? The newest standard (C11)? And what devices are you using C for? I'd assume a standard POSIX environment, but you can't be sure with C.
For this, I can't point to any one source, but I highly suggest looking at the implementations of the C++11 type_traits header. Building off of that would be a great second step.
That is arguably true for the first two books, but Effective STL is very opiniated. Scott Meyers argues not to use for loops when possible and to use the algorithm library everywhere instead. I tried convincing my team to do this but we were using C++03 and writing a struct functor is no fun... I think in C++11 a for loop and even a for each loop should be modernized with a good lambda instead.
OK from that perspective I can relate. Even before using C++11 I was using a lot of the new STL through Boost. If you use Boost, the only fundamental differences are syntax like auto, variadic macros, constexpr, noexcept, and lambdas all of which are familiar enough to get by. The only practical differences that have no equivalent in C++03 is move operations and maybe the threading/chrono stuff. Effective Modern C++ covers that so that's all I needed to "upgrade."
In my limited experience, no. All of the languages you mention put developer experience above portability, so usually require a basic runtime. C on the other hand is not interested in saving you from the machine, which allows for extremely minimal programs. Even C++ isn't great here compared to C. Then again, debugging segfaults isn't for everyone, so most are fine giving up C.
IMO, the classic C++ book/author is still the best: Effective C++. Don't forget about the sequels, including the mostly overlooked Effective STL (which I happen to like better than the first two books). And to address the modern part of this question, I'll add that Scott Meyers has written Effective Modern C++ as well, but I'd read that last after getting the hang of C++03. No matter what people say, I tend to believe C++11 and on is not really a different language as much as it is syntactic sugar to cover up the ugliest parts of C++.
Actually, you might want to glance at the first few hundred lines of platform specific stuff you are supposed to set manually before the main makefile begins. Literally meant to be set by hand, but the Git developers made educated guesses about the specifics of each platform.