California passes groundbreaking open textbook legislation - <AUTHOR> https://creativecommons.org/weblog/entry/34288 <comment><USER2> I am hugely in favor of this move. It's a tiny first step to decreasing the cost of education and further opening educational access to truly everyone.

But, if I may indulge in a cynical moment, I note that one of the touted benefits of CC-BY in the article is that commercial companies can develop tutorials from these tax-payer funded books.

What if the tutorials then become the required texts? Are there any safeguards from this? If not, it's inevitable that it will be done.

<comment><USER3> It would be better if they choose CC-BY-SA, which requires that derived works be under that licence aswell.

(Neither CC-BY nor CC-BY-SA block commerical use, and that's fine IMO)

<comment><USER4> If it was share-alike, why would companies develop tutorials, since they could be re-published by other companies at close to cost price?

<comment><USER3> There are loads of companies the make money off open source software. Same principal.

</comment></comment></comment></comment><comment><USER5> There is something I don't understand. From the article it seems that this only provides for the creation of free/affordable textbooks, but does not force the use of them in colleges. Am I wrong thinking that affordable textbooks are already available? What is being done to prevent colleges and professors from using 150$, annual, nth edition of the same old textbooks?

<comment><USER6> Speaking as a professor, I'd be furious if some legislator told me exactly which textbook to use. I'm concerned about book prices, certainly, but mandating a specific text would immediately shut down the few attempts at innovation in textbooks or curriculum that do exist.

If the new books are of comparable quality to the current market leaders in a given discipline (and especially if we eventually get some competition between free texts), then all that will be necessary will be an education campaign to make sure faculty know what's available. We do care about this stuff! (Or at least, a lot of us do.)

<comment><USER7> And some care about the kickbacks from forcing students to buy $150 textbooks that cannot be bought used because there's a new "edition" every year that shuffles the practice problems.

That's what needs to be prevented in _some_ way.

<comment><USER8> Who's getting kickbacks? I've never gotten a kickback. I really want to know if you know of a kickback scam.

The high prices could be due to just the opposite problem: professors are particularly difficult to sell to. They are _individually_ picky about how their subject matter is presented, and textbook meetings (where we try to agree on the textbook among colleagues at a particular school) are frustrating and difficult.

The time and effort expended in selling those books are (probably) enormous. There's no institutional path-to-sale. Decisions are made by the professors themselves, meaning it's close to b2c marketing of a b2b product. The problem, in business terms (stolen from a VC spiel to an entrepreneur group as to why they don't fund educational software) is that "the customer is dysfunctional."

<comment><USER9> Professors write textbooks and make their students buy them. Thats the scam. I remember vividly the pain during college of buying $150 textbooks that would be worth $30 the next year because a (n+1) edition would be released with a couple new pages just to mess up all the page references and exercises.

<comment><USER8> That's a very small effect. A professor doesn't make much money off of a single textbook- selling to one class wouldn't be worth the trouble of writing. Even revision (working with the editor) is aggravating. And if you have co-authors? Forget it.

Writing the text book is an act of love and/or vanity. Only if your textbook becomes a "standard" (Halliday/Resnick, etc.) does it provide direct financial rewards.

EDIT: I agree with you about the 3-year cycle, but that's not the authors' doing, it's the publishers'. That's _their_ business model.

<comment><USER10> > Writing the text book is an act of love and/or vanity. >

You are making the assumption that the author will make a deal with a traditional publisher which will give him/her a 5% to 10% royalty cut. This strategy does not not come out to a lot of money.

I am currently self-publishing a textbook˚ and getting 75% profit margins: $40 sale price - $10 printing cost = $30. My students and friends have been my editors and my proofreaders. LaTeX is my typesetter. If I can sell 1000 copies each term, that would be $60000/year which would pay my rent and allow me two write for a living.

To be honest, though, I must say that love and vanity also factor into the motivation for this project, yet I had always thought of it as a business all this time. Your comment is spot on dhimes, and made me learn something about my true motivations. Thx!

________

[˚] A math and physics textbook for adults. It covers high school math, calculus, mechanics, E&M and linear algebra in just 350 pages. Email if you want to know more.

<comment><USER8> My friend, unless you are extremely well known or a brilliant self-marketer, you are going to learn something important about the industry. There's a reason that the finances of the industry work out the way they do.

Importantly, if you want widespread adoption, you need to target a course. Yours targets several. I've seen a few hybrid-course experiments where the instructors combine courses that have been traditionally taught separately (like calculus and physics), but they are to my knowledge still rare. I've not seen a course like the one you are writing a textbook for. Who teaches such a course?

<comment><USER10> > if you want widespread adoption, you need to target a course.

You may be right about that, but I think there is also value in a single book which covers all these subjects in an integrated manner. Especially Calculus and Physics, which are very co-dependent.

Imagine the use case of someone who wants to learn science on their own. Perhaps he/she is taking an online course which has calculus, physics and linear algebra as prerequisites. Traditionally this would mean he/she has to get three different textbooks (400+ pages each) and slog through all that material. There are excellent free books out there on all of these subjects so money will not be an issue, but going through 1200+ pages will be very time consuming.

This is the gap I want to fill: (1) textbook for self-learners, (2) add-on material for a university class, (3) reference book for adults who want to review the material they learned while at uni.

For audiences (1) and (3) having an 5-in-1 product is definitely a good thing. For audience (2) having all the extra material might make my book appear off- topic and decrease interest. In the next iteration, I am going to think about splitting the narrative to make books for individual subjects to cater more to (2).

<comment><USER8> I wish you well in your endeavor. It's quite an undertaking!

</comment></comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER11> I work for the California Digital Library, and most of my work involves using or writing open source code; and this establishes the California Open Source Digital Library.

Ironically, we launched a textbook site (only for UC) this week <http://licensed.cdlib.org>

</comment><comment><USER12> I do not know enough about this to be for or against it. But as a recent college grad it leaves me with two obvious questions.

1\. This litigation doesn't address the issue of overpriced textbox, simply bypasses it all together. Is there anyone out there saying that the current selection of textbooks is bad in some way other then there price? I find it astounding that they would pass litigation in an attempt bypassing a whole industry instead of actually addressing the issue.

2\. Why can these textbooks be made without this ligation?

<comment><USER13> Probably trying to bypass Texas, which usually decides text book standards based on market consumption.

Not sure how subsidies are going to make anything "better". I would think it would be a way for a lot of low quality producers to flood the market. Now, rather than competitive pressure potentially keeping quality in place, the state will need to provide oversight functions, either in awarding subsidies, or in mandating (and deciding) what goes into the textbooks, either of which will be another great place for patronage jobs.

</comment></comment><comment><USER14> Sound brilliant with one small question "So, in addition to making the digital textbooks available to students free of cost, the legislation requires that print copies of textbooks will cost about $20. ". Small question about biasing for those students who have access to a device that can read the free open source version, for many a hardcopy is also more suitable. So to legaly control a price saying "about $20" does somewhat raise questions as to the definition of "about" as a fiscal term and more so. Who do you pay to print out your own copy? Becasue as it reads, if you print it out then you should be paying "about $20" for it and this is completely unclear. Least to me it is.

Still motives are good and anything moving in the right common sence direction has to be applauded.

<comment><USER15> Yeah, the $20-to-print requirement will get tricky. Imagine a biology textbook with detailed color pictures. Do you have to remove some because color printing is expensive? Is it acceptable if you can print a text-only version of the book for $20 and look at the pictures online? Is it acceptable to sell a supplementary illustrations book?

The real win here is for students to be able to download the whole book for free. In principle, your entire textbook budget for college could be the price of an e-book reader.

</comment></comment><comment><USER16> So now textbook authors are forced to license their books in such a manner? Or is this a choice that certain authors can make?

If it's the former, financial incentives for textbook authors have fallen precipitously. So, the question is, who's going to write these "free, openly licensed digital textbooks for the 50 most popular lower-division college courses offered by California colleges"? Might the authors receive government subsidies? If this is true, then we're simply shifting from a market mechanism to a government funded model. Either the cost of writing a textbook won't actually change, the quality will go down, or we'll have many fewer options to choose from.

<comment><USER17> "So now textbook authors are forced to license their books in such a manner?" No. This would be much bigger news if that were the case. This is who would make them from the council digest: "The bill would require the council to establish a competitive request-for-proposal process in which faculty members, publishers, and other interested parties would apply for funds to produce, in 2013, 50 high-quality, affordable, digital open source textbooks and related materials, meeting specified requirements." This will enable the exact opposite of your last three conjectures. It will decrease the cost of textbooks, the quality will go up, and we'll have even more options to choose from. Plus this is a big win for other educational enterprises. Under the CC BY license outside industries will be able to utilize the material for commercial endeavors.

</comment></comment><comment><USER18> I offer a Linear Algebra that is Free. Some years ago I was contacted by some people in California and prompted to apply to become some kind of official Free source in that state; it involved filling out some forms on some web sites. That I can tell, nothing ever came of it. So I'm a bit dubious about this initiative.

</comment><comment><USER19> I love his response in the video. Seems like it took the guy only a couple of seconds to realise how much sense the idea makes. He would have done his research prior to the meeting but his attitude toward it is great.

</comment><comment><USER20> So which textbooks will this include? Do they need the publishers' permission to redistribute their existing work under a CC BY license?

<comment><USER2> Quoting from the linked text of SB 1052

"The council shall establish a competitive request for proposal process in which faculty members, publishers, and other interested parties may apply for funds to produce the 50 high-quality, affordable, digital open source textbooks and related materials in 2013.

Nothing in this subdivision shall be construed to limit or restrict the council from developing or acquiring, either for a charge or for free, existing high-quality digital open source textbooks and related materials that otherwise meet the specifications of this section."

So it looks like next year there will be a RFP for funds for developing the texts (assuming they don't use existing digital open source texts). And anyone (including folks here) could apply to that RFP, though I assume people used to the process will have a distinct advantage.

An earlier section of the bill establishes a committee to determine exactly which 50 books will be developed.

</comment></comment><comment><USER6> I wonder if they'll use the existing CC-BY textbooks produced by OpenStax (or others) for some of these courses? <http://openstaxcollege.org/>

</comment><comment><USER21> As a non-California resident, Jerry Brown seems to be doing a pretty impressive job. He seems to talk about the real issues, especially when Cali's budget, and puts good legislation through.

<comment><USER22> Brown is a California resident.

<comment><USER21> I meant to say "from the perspective of a non-California resident"

</comment></comment></comment><comment><USER23> The idea is great but the textbook companies just will tack on manditory $85 software while not having to pay book royalties... the insanity shall continue.

</comment><comment><USER24> Curious if any fellow HN'ers know when these textbooks would be made available. Dont see any info on the linked page.

<comment><USER25> One of the bills establishes a committee to select the courses, so presumably it will be a little while.

</comment></comment><comment><USER26> Great step from california. Hoping that some `indian` politician read this :-)

</comment><comment><USER27> Feynman would be happy.

</comment><comment><USER28> Fucking finally.

I hope the rest of the country follows.

p.s.

It's pretty sad this obvious move is considered "groundbreaking". All it took is a pair of balls.

</comment><comment><USER29> Alright, textbooks are expensive and it's a step in the right direction. But with average costs for textbooks around $1,200 per year it's not much compared to the cost of tuition.

<comment><USER30> Consider community colleges. At least in California, their tuition is still low enough that textbooks are a significant portion of the cost.</comment></comment>


Undefined Behavior in 2017 - <AUTHOR> https://blog.regehr.org/archives/1520 <comment><USER2> > Loops that Neither Perform I/O nor Terminate

> Summary: This UB is probably not a problem in practice (even if it is > moderately displeasing to some of us).

Since LLVM is mostly based around C/C++ semantics this actually turned out to be a problem for rust, because rust can encode diverging functions in its type system and assume certain code sections to be unreachable. If the compiler then optimizes out code and the unreachable (thus not-compiled) section is reached things explode.

[https://github.com/rust-lang/rust/issues/28728](https://github.com/rust- lang/rust/issues/28728)

<comment><USER3> I think that's a great example of how optimisers have gone off the deep end: no reasonable human programmer would think "I can't figure out if this loop terminates, so let's just leave it out", but that appears to be the default behaviour in this case --- when what should happen when the optimiser "gives up" is that it should just translate the code verbatim.

<comment><USER4> But the optimizer doesn't give up in this case. It successfully figures out that the loop has no side effect except heating up your processor and eliminates it.

<comment><USER5> What's the advantage of eliminating the loop?

If the compiler is able to do that analysis, why not flag the endless spin loop as a compilation error?

<comment><USER6> Loop is inside a function, that can have no side effect conditionally.

Function is used in multiple places and inlined.

With inlined context, compiler can eliminate loop sometimes.

</comment></comment></comment></comment></comment><comment><USER7> The main message from my point of view:

> Be knowledgeable about what's actually in the C and C++ standards since > these are what compiler writers are going by. Avoid repeating tired maxims > like "C is a portable assembly language" and "trust the programmer."

> Unfortunately, C and C++ are mostly taught the old way, as if programming in > them isn't like walking in a minefield. Nor have the books about C and C++ > caught up with the current reality. These things must change.

<comment><USER3> I think it's the _compilers_ that have perverted the language to such an extent that it's become ridiculously difficult to understand, and so it's the compilers that must change back to being less obtuse and adversarial.

The C standard even suggests, when defining undefined behaviour, that one of the possible options is "behaving during translation or program execution in a documented manner characteristic of the environment". If signed int arithmetic on the hardware wraps around upon overflow, then take that into account when optimising and don't assume it can't overflow. This is how C programmers want the language to work; compiler writers and standards be damned.

I've written plenty of Asm and also looked at as much if not more compiler output; and while the latter sometimes pleasingly surprises me, it's usually pretty evident that it was not generated by an intelligent entity. (And countless times, I've obtained size and/or speed savings by replacing the latter with what I would otherwise write.) My general impression is that there aren't enough highly-skilled Asm programmers working on compiler development --- there are many reasons I can think of for that, but one of the things I've always wished to exist is a simple, straightforward C compiler with "understandable" output and optimisation that creates results closer to what a human Asm programmer might write; with the associated optimisation advantages and predictability. This means _not_ assuming anything just because the standard says so, but taking a more holistic (for lack of a better word) approach to compilation and optimisation.

A long-time favourite post on this: [http://blog.metaobject.com/2014/04/cc- osmartass.html](http://blog.metaobject.com/2014/04/cc-osmartass.html)

<comment><USER8> > If signed int arithmetic on the hardware wraps around upon overflow, then > take that into account when optimising and don't assume it can't overflow. > This is how C programmers want the language to work;

Don't speak for all of us.

Some of us may take the language for what it is, instead of assuming it to be a "high level portable assembler" which it is not, but which a particular implementation of it _may_ be, thanks to the standard leaving much up to the implementation.

It is this same leeway that (thankfully) allows smart optimizing compilers that can generate performant code for programs that are not omgwtf-optimized at the source level.

And it is this same leeway that allows very simplistic, naive implementations that do not go out of their way to perform crazy analysis to try and warn you about some corner case of undesirable behavior your code might hit.

You're right that it is the compilers can and need to change to accommodate different types of users. But I don't think every compiler should just go back to being a 1991 compiler; not every compiler needs to accommodate every user.

<comment><USER9> They CAN accommodate all users, just have compile time options you can enter in your make file/on the command line/etc to say what level of bounds checking/etc you want compiled into your code. Hell that way even within a given project you can choose "this library I'm nervous about so I'll eat the hit on bounds checking".

<comment><USER7> They do it, but the performance culture among C devs doesn't appreciate enabling them.

[https://gcc.gnu.org/onlinedocs/gcc-7.1.0/gcc/Object-Size- Che...](https://gcc.gnu.org/onlinedocs/gcc-7.1.0/gcc/Object-Size- Checking.html#Object-Size-Checking)

[https://gcc.gnu.org/onlinedocs/gcc-7.1.0/gcc/Pointer- Bounds-...](https://gcc.gnu.org/onlinedocs/gcc-7.1.0/gcc/Pointer-Bounds- Checker-builtins.html#Pointer-Bounds-Checker-builtins)

I bet not much UNIX software compiled with gcc enables them.

Android is probably the only OS that does make use of them.

[https://android-developers.googleblog.com/2017/04/fortify- in...](https://android-developers.googleblog.com/2017/04/fortify-in- android.html)

<comment><USER10> The performance culture isn't just C. Far from it.

Rust was susceptible to Stack Clash because they ripped out their existing stack probing to gain a few percent increase in performance.

The article for this thread literally says, "For many use cases ASan is the better choice because it has much less overhead." IME Valgrind does a _much_ better job of detecting memory issues, partly because ASan only detects issues directly triggered in the code that you compile, whereas Valgrind can detect memory issues directly triggered by external code, but indirectly caused by your code.

<comment><USER7> > The performance culture isn't just C. Far from it

Sure, but it is where it is more visible, specially micro-optimizing code as it is being written, without validating if it really matters to the application's use case with a profiler.

The school of systems programming languages from Algol side, was that correctness was much more relevant than pure performance, Algol dialects for systems programming already had Rust like unsafe blocks in the mid-60's.

In Burroughs B5500 the administrator could enable which applications with unsafe modules were allowed at all to be executed, 10 years before C was invented.

<comment><USER10> I've never met a C programmer or C compiler author who felt correctness should take a backseat to performance. And as I demonstrated, the Rust designers are hardly immune to poor decision making on this score.

Someone else corrected me regarding the stack probes--Rust didn't have probes but actually checked the size of the stack. It's also worth pointing out that often times decisions are premised on maintenance burdens. Performance was one excuse for removing the stack checking in Rust; the other was the maintenance burden of maintaining a feature outside of LLVM.

That goes directly to the heart of the undefinedness issue in C. Doing the "obviously correct" thing wrt to choosing between possible undefined- or implementation-defined behaviors isn't as easy as we think. Good compilers are built on abstractions and code reuse, like any other piece of well-written software. Doing the correct thing in some obvious cases can result in having to make non-obvious tradeoffs elsewhere, possibly having to choose between adding (or maintaining) complexity, or removing a powerful feature, such as deterministic stack overflow prevention.

The history of C (indeed, Unix and the whole "worse is better" school of design) is about favoring less complexity in the tooling while shifting more of the burden onto the user. That's a judgment not about runtime performance, but a very unintuitive judgment about the performance and efficiency of programmer time; that you quickly reach a point of diminishing returns, much sooner than most people believe, putting complexity into, and relying on intrinsic features of, the tooling; that it's often better to make it easier to implement and integrate specialized tools, and easier to reuse existing tools as part of a more focused solution. From that perspective the design of C makes a ton more sense, even if reasonable people can still disagree about the results.

The notion that C--the language design, the ecosystem--is principally about performance is something mostly held by inexperienced programmers. It's a strawman of critics. There were plenty of other languages from the 1970s that were capable of generating faster code than C. Certainly performance was and continues to be of significant concern, but C is hardly unique in that sense. If the debate about how to balance performance with other issues stands-out, I'd argue that's primarily because of C's ubiquitous position and how it and the computing industry (including hardware industry) has co-evolved.

When something seems so "obvious" (security vs performance), yet everybody continues to seemingly repeat the same dumb mistakes, often times what we're missing is that our premises are flawed. Maybe C didn't become ubiquitous because of it's performance, but more so because it was easy to port and easy to build upon. After several years Rust still has a single implementation. Even Go has two production-quality implementations. That's not a criticism of Rust, just an observation that the "security vs performance" axis is hardly the only relevant dimension for judgment and explanation.

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER11> How many of these 200+ undefined behaviours exist in more modern low-level languages, such as Rust and D?

<comment><USER12> LuaJIT is another modern low-level language. It has some remarkable undefined behavior like the evaluation order for function arguments. Scares me a bit.

[https://github.com/LuaJIT/LuaJIT/issues/238](https://github.com/LuaJIT/LuaJIT/issues/238)

<comment><USER13> The same is true in C/C++: Function argument evaluation order is unspecified. BUT: that doesn't mean this is undefined behavior, it is just unspecified.

unspecified != undefined behavior

See this Stack overflow answer for an explanation: [https://stackoverflow.com/questions/2397984/undefined- unspec...](https://stackoverflow.com/questions/2397984/undefined-unspecified- and-implementation-defined-behavior)

</comment></comment></comment><comment><USER14> I wonder why he mentions this TIS interpreter but not the development of complete semantics for C and specifically the k framework ([https://github.com/kframework/c-semantics](https://github.com/kframework/c-semantics)).

Afaik, kcc is also really good at finding undefined behavior. Regehr even wrote about it in the past ([https://blog.regehr.org/archives/523](https://blog.regehr.org/archives/523)).

<comment><USER15> AFAIR from the last presentation on the K framework I attended (a year ago), the publicly available version of their C interpreter is incomplete: It only runs programs that don't need the standard library. That's pretty great for many things! But it's not a turnkey solution for analyzing real applications. For that they had a proprietary commercial version. (Again, this is from memory, and it may have changed.)

Another reason to mention TIS-interpreter specially is that Pascal Cuoq (the co-author of this blog post) is one of its developers, and his livelihood depends on it being used.

<comment><USER16> Original developer of the C semantics in K here! I just wanted to add a pedantic clarification (since pedantry is what semantics is all about).

The semantics of the language itself is more or less complete. On top of that, a sizable portion of the standard library is given semantics directly (e.g, malloc, setjmp, stdargs, I/O including input/output to FILEs, much of printf, etc. are all formalized in the semantics). There's even basic C11 thread support. All of this runs and can be reasoned about formally. I tried to give direct semantics to the things that couldn't be (easily) written in C, because much of the standard library CAN be written in C and so it isn't so critical that it's formalized.

To round out the library you can provide provide C implementations of any missing library functions at compile time (we provide some by default), and it will KCC those just like any other code. The resulting system is pretty good at catching undefined behavior, but it is super slow.

I'm not involved with the commercial version, but they offer a trade off: don't do any semantic checking inside standard library calls in exchange for faster execution times. My understanding is that instead of chugging through the semantics of printf for every bottle of beer on the wall, they just call out to a native of printf. This makes things a lot faster, but it's possible you won't catch as many problems. In general, the commercial version is trying to make using the semantics practical instead of "academically slow", which was all I managed :)

Any questions welcome.

<comment><USER15> Thanks for the clarification! That's kind of what I remembered, but you explained it much better.

</comment></comment></comment></comment><comment><USER17> Mitigation: Stop using languages that let you run roughshod over memory like C and C++ do.

</comment><comment><USER18> I wish there was a GCC switch that made the optimizer go "This is clearly undefined behaviour. I'll stop this compile right here", as opposed to "This is clearly undefined behaviour. Sweet jackpot, it means I can do whatever the heck I want. Drop those NULL checks below, I've got the golden UDB ticket now"

<comment><USER19> The optimizer doesn't work that way. It _assumes_ the code does not do UB _and then_ removes branches that can never be taken if the code executes no UB.

That's different from "This is UB, and now I do ...".

<comment><USER20> I think we deserve a compiler warning whenever a _source_ line of code (not a line generated by the preprocessor) gets removed due to UB exploitation. All such cases are worth the programmer's attention, because they are either useless lines or bugs.

<comment><USER21> It's more complicated than this, unfortunately. Imagine an int variable x and two expressions f(x) and g(x) of x. Now imagine an if statement with condition f(x) < g(x). Precisely because incrementing the largest int is undefined behavior, the compiler may be able to simplify the if condition because, for example, it can assume x+1 > x is always true. So it's not necessary for the line to be useless or wrong for undefined behavior rules to trigger compiler optimizations.

</comment></comment></comment></comment><comment><USER22> Why don't compilers have an option to reject UB with an compiler error? Surely the compiler must know when it comes across a piece of source code whose semantic is undefined.

<comment><USER19> Because a lot of UB cannot be efficiently determined at compile time. Hence, UBSan.

<comment><USER7> It is very easy to be efficiently determined at compile time, other systems programming languages do it, by not having UB on their language standard to start with.

If people prefer "performance trumps correctness" and "winning compiler benchmarks is what counts" then they should happily keep getting exploited.

<comment><USER23> "Very easy" \- well, if you think garbage collection is easy...

And yes, if you want to allow manual allocation of objects and setting pointers to arbitrary objects, then your two choices are: 1) garbage collection 2) undefined behavior (use-after-free, double-free, dangling pointers, etc.)

<comment><USER7> > garbage collection is easy...

Garbage collection isn't the only way of writing _mostly_ safe systems programs.

ESPOL, NEWP are 10 year older than C.

PL/8 was the systems programming language used by IBM for their first RISC mainframe, followed by PL/S.

Mesa used at Xerox PARC.

Modula-2 used at ETHZ and many 16 bit systems.

Object Pascal used to write the first versions of Mac OS and Lisa.

Ada and SPARK used by high integrity systems where human lives can be at risk.

All of them with not even a quarter of C's UB collection.

<comment><USER23> Well, I don't know about half of these programming languages. However:

\- ADA requires garbage collection

\- Modula-2 and Object pascal have manual memory management, i.e.: "new" and "delete" \- together with double-free, use-after-free, and dangling pointers...

I agree that C is by far worse, but please recognize that at least some of the undefined behavior problems are really hard to solve.

EDIT: Oh, and we haven't started talking about multi threading yet, have we?

<comment><USER7> What about learning to understand English?

"writing mostly safe systems programs."

Do you understand what _mostly_ means?

Ada and Modula-2 have multi-threading as part of their ISO/ANSI language standard.

Also you don't seem to know much about Ada given your GC remark, but here is some learning.

[https://archive.fosdem.org/2016/schedule/event/ada_memory/](https://archive.fosdem.org/2016/schedule/event/ada_memory/)

Of course there are still use cases where Algol derived languages are still unsafe, however those use cases are a tiny portion of what happens in C land.

<comment><USER23> > What about learning to understand English?

That's uncalled for, man...

> Of course there are still use cases where Algol derived languages are still > unsafe, however those use cases are a tiny portion of what happens in C > land.

On that I agree - there are many problems we wouldn't have if we were using, say, pascal or modula.

> Also you don't seem to know much about Ada given your GC remark, but here is > some learning.

I'm sorry, I don't have time to watch that. However, I know that ADA has either GC or manual memory management (with the deallocation method explicitly marked as unsafe). Thus, as far as i know, constructing "use-after-free" in Ada is possible - which is undefined behavior (and that was my point).</comment></comment></comment></comment></comment></comment></comment></comment>


Ask HN: Why ask for address on a job application? - <AUTHOR>

I've been applying to jobs online, and a lot of businesses have their own employment portal that they make you go through. I've encountered quite a few that require I fill in my home address.<p>Why do they need my home address, or any address of any kind? With privacy flaws rampant in the wild, I don't know if I trust any company (even big name ones like Google) to hold my data. Are they going to sell my data and all others who have applied? What do they need it for? <comment><USER2> Someone asks: "Hey, what information should we ask for on the form?"

Response, without much thought given, because the person answering has a lot going on: "The usual stuff... Name, address, phone number, email, resume, work history, etc."

And it never gets changed because:

1\. Changing it isn't a priority. 2\. It's information that they'll need from hired applicants, anyways.

</comment><comment><USER3> Just make something up.

<comment><AUTHOR> Yeah, that's what I did. I don't see why they need it. It would be nice if someone who built such a portal could answer why.</comment></comment>


Zest docs browser — gathering feedback - <AUTHOR> https://email@example.com/show-hn-zest-documentation-browser-d45b890d38a5 <comment><AUTHOR> Oops. Forgot to read 'Show HN' rules before posting it. Renamed.

(Referring to "For example, blog posts, sign-up pages, and fundraisers can't be tried out, so they don't count as Show HNs." at [https://news.ycombinator.com/showhn.html](https://news.ycombinator.com/showhn.html))

<comment><USER2> I suspect that making something that meets those guidelines would produce better feedback since it would be on execution over an idea.

Good luck.</comment></comment>


Health Insurers Are Vacuuming Up Details About You–And It Could Raise Your Rates - <AUTHOR> https://www.propublica.org/article/health-insurers-are-vacuuming-up-details-about-you-and-it-could-raise-your-rates/amp <comment><USER2> Previous discussion: [https://news.ycombinator.com/item?id=17550315](https://news.ycombinator.com/item?id=17550315)</comment>


A deeper reason why programmers aren't reading books  - <AUTHOR> http://ripplingbrainwaves.blogspot.com/2008/05/deeper-reason-why-programmers-arent.html

<comment><USER2> I read books to understand concepts and technologies at a higher level (I particularly like the Head First series), but Google has largely replaced my day to day use of books as programming references.</comment>


Development on Torus at CoreOS Stopped as of Feb 2017 - <AUTHOR> https://github.com/coreos/torus/pull/449/files <comment><USER2> Same submission, with more points and comments: [https://news.ycombinator.com/item?id=13678979](https://news.ycombinator.com/item?id=13678979)

</comment><comment><AUTHOR> rook (which was linked in the README) looks pretty nice, though it's still in alpha (it wraps Ceph and etcd to easily run a ceph cluster, managed internally by rook). [https://github.com/rook/rook](https://github.com/rook/rook)</comment>


What Old Transit Maps Can Teach Us About a City's Future - <AUTHOR> http://www.citylab.com/commute/2014/10/what-old-transit-maps-can-teach-us-about-a-citys-future/381149/

<comment><USER2> Curse you, MARTA! As a Seattleite and urban planner, I have a particular sadness with respect to MARTA. The plan in the late 1960s was for a heavy commuter line like BART or MARTA to be built in Seattle with 20% local match, and 80% federal funds. Seattle voters rejected it. Federal funds went to Atlanta.

While this was really Seattle's fault, I still find it more convenient to direct my anger toward Atlanta.</comment>


My key takeaways from Y Combinator's Startup School 2012 - <AUTHOR> http://nowaternomoon.com/post/34062996874/my-key-takeaways-from-y-combinators-startup-school <comment><USER2> I was there. And I can say that this would not be my summary of Startup School. This summary makes me question every other summary of events on HN. Not to say that the author didnt provide a good summary for himself, but instead I now realize how radically differently two people can perceive the same event, based on their experience.

<comment><USER3> I couldn't be there, but I would be very interested to hear your perspective.

<comment><USER4> I posted my takeaways on Quora (second one, currently)

[http://www.quora.com/Startup-School/What-were-the-key- takeaw...](http://www.quora.com/Startup-School/What-were-the-key-takeaways- from-Startup-School-2012)

I agree that two people can have vastly different takeaways from an event like this, but don't see anything wrong with that. Different people have different backgrounds and different things they wanted to learn going in.

<comment><USER5> Thank You. Upvoted (both here and on quora) That was a very interesting bunch of takeaways. I found them more interesting than the ones in the OP.

I wasn't there so I'm probably imagining things, but I'm getting the vibe that the VC/investor types were giving canned pop psychology 'MBA'/management consulting type advice like advice, where the hacker/founder folks _sound_ more original (and useful).

</comment></comment></comment></comment><comment><USER6> Patrick Collison of Stripe, his quote is a paraphrase of the US Tour de France winner Greg LeMond, "Training doesn't get any easier, you just go faster.".

Another of LeMond's that I always felt applicable was, "You don't suffer, kill yourself and take the risks I take just for money. I love bike racing.".

You better love what you do.

<comment><USER4> It wasn't paraphrased, he gave a direct quote and a picture of LeMond was one of his slides.

</comment></comment><comment><USER7> I enjoyed reading this.

My takeaway from his takeaways would be:

1\. Commitment matters. Stop talking, make it happen. - _Ben Silberman_

2\. Don't worry about competition, just improve yourself. - _Hiroshi Mikitani_

3\. Failure to decide is what kills you. - _Joel Spolsky_

I've shortened the Joel's quote because your inability (unwillingness) to decide whether you'll 'get big fast' or have an 'organic growth' is not the only place where indecision shows its ugly head.

</comment><comment><USER3> Thank you for sharing this! Does anyone know if YC will post the video? I couldn't watch the live stream on Saturday.

Too bad about Instagram for Squirrels. I would've been one of their 5 users.

</comment><comment><USER8> Did Zuck really claim: "Human is the only animal who dreams about social interactions"?

<comment><USER4> Yes, or something very close to that.

</comment></comment><comment><USER9> "Human is the only animal who dreams about social interactions."

How could we possibly know that?

</comment><comment><USER10> Is there video of this event anywhere?

<comment><USER11> There are some videos at <http://www.youtube.com/user/mshelengelena> but it's not complete and doesn't appear to be official.

</comment></comment><comment><USER12> Also, Ben Horowitz apparently not a fan of "bitch ass ness"

</comment><comment><USER13> Good photos - did you take them?

<comment><USER14> Yup. Most - on my camera, some - on the phone.

</comment></comment><comment><USER4> Good post.

"Palantir (I didn't understand the market)" I'm pretty sure he said he didn't understand the size of the market. Subtle but important difference.</comment>


Out-of-bounds write in systemd-resolved with crafted TCP payload - <AUTHOR> http://openwall.com/lists/oss-security/2017/06/27/8 <comment><USER2> I misparsed this as "A bug regarding an OOB write in systemd has been resolved by deployment of a crafted TCP payload" and was hoping for a legendary tale of deeply grey-hat infrastructure hack-patching.

</comment><comment><USER3> Remind me, why are such critical system components as systemd are still being written in a memory unsafe language?

<comment><USER4> Yeah, we really should rewrite the kernel.

<comment><USER5> Err, that is not an excuse. That just leads to the question of why there is a second kernel metastasizing in userspace.

</comment></comment></comment><comment><USER6> previously: [https://news.ycombinator.com/item?id=14652787](https://news.ycombinator.com/item?id=14652787) (5 days ago, 192 points, 237 comments)

</comment><comment><USER7> Sorry, but this is not a standard TCP payload. I think the bug is in the library that made the packet, not with systemd. They should fix their library.

<comment><USER8> Anything Internet-facing has to accept any kind of packet without crashing, or at least without failing in an exploitable way. That's the bare minimum you- must-be-this-tall entry requirement of security.

<comment><USER3> I believe it was a joke about how Lennart Poettering usually responds to bug reports.

<comment><USER7> You are correct. See, for example, his recent response to the issue where systemd starts processes belonging to users whose usernames begin with a digit with root privileges: [https://github.com/systemd/systemd/issues/6237#issuecomment-...](https://github.com/systemd/systemd/issues/6237#issuecomment-311900864)

My deepest apologies to HN for the overly-dry sense of humor.

<comment><USER5> [https://en.wikipedia.org/wiki/Poe's_law](https://en.wikipedia.org/wiki/Poe's_law)

</comment></comment></comment></comment></comment><comment><USER9> _" A patch to resolve this has been provided..."_

The patch resolves the resolver. Heh.

</comment><comment><USER10> OT, but I wonder why Poettering chose Kay Sievers to work on systemd in the first place.

<comment><USER5> Both are Germans, and work at RH.

Frankly the more i look at things, the more i find a small group of people at the RH German office to be the source of recent turmoil.

<comment><USER10> Was that the only reason?</comment></comment></comment>


P2P takes on Ebay - <AUTHOR> https://torrentfreak.com/steal-show-s01e05-p2p-takes-ebay/ <comment><USER2> I'm very eager for this. Always neat to listen to their actual voices...the developers sound like very intelligent people (of course that itself doesn't mean anything).</comment>


Government Shuts Down as Congress Misses Deadline - <AUTHOR> http://online.wsj.com/article/SB10001424052702304373104579107051184641222.html <comment><USER2> From the perspective of someone who live in a Westminster-style democracy this is made especially bizarre by virtue of the fact that failing to be able to pass a budget bill results in new elections[1]. If you're going to block the budget, you'd better be damned confident that voters agree with you.

[1] I suppose technically it results in the head of state inviting other political partites to form a government, and then calling elections when they can't.

</comment><comment><USER3> We had two similar "partial shutdowns" of the US Gov't in the 1990's. Democratic President refusing to cut healthcare-related spending vs. Republican-controlled Congress holding the debt ceiling hostage. Sound familiar? Same game, different players.

[http://en.wikipedia.org/wiki/United_States_federal_governmen...](http://en.wikipedia.org/wiki/United_States_federal_government_shutdown_of_1995_and_1996)

<comment><USER4> In the 90s Congress failed to pass a budget. Holding the debt ceiling hostage was never seen or tried as a legitimate political tactic before the last few years.

<comment><USER3> Nope. In the former speaker's own words...

[http://www.cnn.com/2013/09/19/opinion/gingrich-obama- congres...](http://www.cnn.com/2013/09/19/opinion/gingrich-obama- congress/index.html)

</comment></comment></comment><comment><USER5> I imagine a Koch brother handing the other a single $1 over a bet they could shutdown the government like in Trading Places.

<comment><USER6> Maybe the loser has to donate an extra million dollars or so to the winner's favorite charity?

[http://www.politicsdaily.com/2010/09/02/koch-brothers- give-m...](http://www.politicsdaily.com/2010/09/02/koch-brothers-give-more-to- charity-than-to-right-wing-causes/)

</comment></comment><comment><USER7> Wouldn't it be nice if the federal government were small enough that it contained no personnel who were "non-essential" ?

<comment><USER8> It's impossible to have only "essential" staff as you will always need "non- essential" staff to support their work. For example, NASA TV employees are "non-essential" [1] but without the TV station it may mean lots of kids are not inspired by NASA any more. Also, Labor statisticians are "non-essential" but would you rather the Department of Labor make decision on gut feelings instead?

[1] [http://www.nytimes.com/interactive/2013/09/27/us/who-goes- to...](http://www.nytimes.com/interactive/2013/09/27/us/who-goes-to-work- during-government-shutdown.html?_r=0)

<comment><USER9> I'd rather not have a Department of Labor.

</comment></comment></comment><comment><USER10> One sad aspect of this is that it won't have any effect on the income of the involved politicians.

<comment><USER11> If they were on suspension too, how would they get together to eventually agree a fix? I agree about the incentives being wrong, and I think the whole thing is ridiculous, but unfortunately, they're exactly the ones who have to keep working until it's over.

<comment><USER10> Doesn't have to be all or nothing. But they are responsible for this mess, so cut their income by 50% or even just 25% for the time. Or reducing their income by X% each day where they can't find a solution.

</comment></comment></comment><comment><USER12> Does anyone know how would this affect public schools?

<comment><USER13> I've always been under the impression that public schools and police services are all managed by state/local taxes and not tied to the federal budget.

<comment><USER14> They get federal dollars for certain things, but you are correct that they are managed and largely paid for by their respective state.

</comment></comment></comment><comment><USER15> I can't understand this. What is meant by Government Shuts Down? No law and order will be enforced?

<comment><USER16> The US government is on _partial_ shutdown. So many hundreds of thousands of US government workers will either 1. not be paid to work, or 2. be furloughed (not go in to work). This applies to non-essential workers (found a list here - [http://www.cnn.com/interactive/2013/09/politics/government-s...](http://www.cnn.com/interactive/2013/09/politics/government- shutdown-impact/index.html?hpt=hp_t1) ).

Retroactive pay will apply once things are worked out.

<comment><USER17> One important thing not to forget, Partisan issues aside, is that both Congress and the President still get paid without any hiccups.

<comment><USER18> Congress and the President are both required to be paid by the Constitution (20th amendment and Art 2, Sec 1, respectively).

<comment><USER19> Ah, so they like that part of the constitution.</comment></comment></comment></comment></comment>


Google Faces Deluge of Nexus One Complaints - <AUTHOR> http://www.pcworld.com/article/186399/google_faces_deluge_of_nexus_one_complaints.html

<comment><USER3> The PCWorld article is a bit overblown, but I expect this to be the first signs of an ongoing problem for Google. I know I've personally had a nightmarish time getting in touch with Google support, for both AdSense and App Engine, and I know Patrick had similar experiences with AdWords. I'm sure there are others.

In the past, Google's paying customers have been primarily tech savvy, and thus more apt to try to solve the problem themselves, contacting support as a last resort. With a more mainstream customer base I suspect this won't be the case.

Even if the Nexus One was bug free, there's going to be people who have problems and want support. For better or for worse, this is the "Google phone" and a large number of people are going to expect Google to help. A phone company with no phone support is just not going to fly.

I for one hope this forces them to improve their customer support across the board. Their lack of support is a serious concern for potential enterprise customers.

<comment><USER4> It's very overblown, I got a Nexus One and the complaints on the forums were there before the phone was even out. Granted there are some specific serious issues that need to be taken care of with support (of which none I've seen on the forums), but the majority of problems and complaints can be easily solved by simply reading. While I agree and think google should have good customer service all around, in my experience the nexus one works just as it should and are many videos from google detailing its features.

</comment></comment><comment> joe-mccann Nice work PC World. You've successfully landed more traffic to your site with a misleading headline. A deluge of complaints? Horseshit.

I personally had countless issues ordering the Nexus One on Tuesday and Wednesday as a current T-Mobile customer with the G1. However, the error I kept receiving was on T-Mobile's side. "T-Mobile's servers are busy/non- responsive" something like that...

I ordered it Thursday around Noon CST with custom engraving and received free overnight shipping with no problems whatsoever. I received an email saying the device had shipped 90 minutes later.

Phone arrived yesterday. Charged it. Plugged in Google Account credentials and have had ZERO problems. Currently uploading/syncing a ton of pics I have taken with the Nexus One to my Picasa account, while transferring a 320kbps MP3 file via Bluetooth, with Pandora playing...with not a single hiccup.

In my opinion, one can expect someone to receive LOADS of negative press when they attempt to do something no one else has done, namely, sell smart/super phones directly to the consumer over the web. I think the only thing Google forget was to put the "Beta" badge somewhere on the ordering site...

<comment><USER5> just curious, how do you plan on selling your phone with custom engraving? i never understood why people opted for that.

<comment><USER6> do people often sell phones?

<comment><USER7> I've unlocked and resold both of my prior-generation iPhones. Even though they were both used, they went for more than I paid for them.

<comment><USER8> People's brains stop working when they are given the opportunity to buy last- generation Apple hardware. That is not the case with anything else, though.

</comment></comment></comment></comment></comment><comment><USER9> > Google appears to be only accepting e-mail customer queries, to which it > pledges to reply in one to two days -- far too long, say most people who are > complaining online.

This is the classic sign of bad service.

You can see this with any bad company (such as ISP) - they want non-telephonic complaints so that it takes an extensive time to respond and most people just give up.

</comment><comment><USER10> Customer service is more than an algorithm.

</comment><comment><USER11> Sounds like the epic battle I had trying to cancel my Sprint wireless card. I'd say my experience in dealing with Google Apps support has been good - <USER2> were slow to answer emails, but quick to pick up the phone, and were warm and personal.

</comment><comment><USER12> They're going to learn the hard way that there is no such thing as a "Beta" version for a hardware product, atleast not in the US.

</comment><comment><USER13> A bunch of people talking back/forth on one page is hardly a deluge of complaints. Perhaps that list had 15 people? I didn't count.

It's an interesting problem I had not thought of, who handles the problems that come up?

<comment><USER4> HTC is supposed to handle hardware warranty related issues and your network provider deals with network problems.</comment></comment>


Do startups create or destroy jobs? - <AUTHOR> http://www.gsb.stanford.edu/insights/george-foster-are-startups-really-job-engines

<comment><USER2> [http://www.technologyreview.com/featuredstory/531726/technol...](http://www.technologyreview.com/featuredstory/531726/technology- and-inequality/)

"According to Chris Benner, a regional economist at the University of California, Davis, there has been no net increase in jobs in Silicon Valley since 1998; digital technologies inevitably mean you can generate billions of dollars from a low employment base."</comment>


Values Are the Rules You Break - <AUTHOR> https://8thlight.com/blog/stephen-prater/2020/09/15/values-rules-break.html <comment><USER2> >Usually, this isn't because your developers don't understand "the rules" and / or don't like you—it's because they know what the organization values, and those values are in conflict with your "rules," and they're trying to deliver that value.

I'm bailing out here. Tautological statements that your actions already represent your desires are a rhetorical tarpit.

After the unnecessary effort to work backwards from what was originally communicated, it will become one of:

A) A narrow message presented as a wide message

B) a motivating lie meant to reinvigorate people into working on second order desires

C) an unnecessarily bold proclamation that the process of change is complicated (and you might be setting yourself up for failure)

D) obviously incoherent and unfounded rubbish which ought to be ignored

</comment><comment><USER3> > There's a military axiom—"You can dictate results or you can dictate > process, but not both.

This certainly doesn't apply to the domain of critical-systems software engineering. I realise the emphasis of the article is meant to be agile methods, but the claims made seem quite categorical, and they don't hold up.

The most well-known coding-standard of this sort is MISRA C. NASA has one too, as does the Joint Strike Fighter project, and there are plenty of others. When these standards are taken seriously, developers aren't permitted to treat them as mere guidelines.

Plenty of organisations may be sloppy with their enforcement of coding standards. It's also possible for bad standards to be actively counterproductive. That doesn't mean they're always misguided and always impossible to enforce.

> The problem with abandoning the fear of failure is that it requires trusting > our developers, a lot.

I defer to an excellent article on critical-systems software development: [0]

> _the culture is equally intolerant of creativity, the individual coding > flourishes and styles that are the signature of the all-night software > world. "People ask, doesn't this process stifle creativity? You have to do > exactly what the manual says, and you've got someone looking over your > shoulder," says Keller. "The answer is, yes, the process does stifle > creativity."_

> Real software quality is not a set of shared rules, but a set of shared > values.

There's a reason avionics software development does not share this contempt for rules. Of course, there's far, far more to building life-and-death software than just following a coding-standard, but still.

[0] [https://www.fastcompany.com/28121/they-write-right- stuff](https://www.fastcompany.com/28121/they-write-right-stuff)</comment>


Thirty Years After Manufacturing Consent, How Mass Media Keeps Thought Inbounds - <AUTHOR> https://taibbi.substack.com/p/introduction-the-fairway <comment><USER2> Great read!</comment>


Java is not a safe language - <AUTHOR> https://lemire.me/blog/2019/03/28/java-is-not-a-safe-language/ <comment><USER2> Honestly, I have a problem with the term "safety" WRT programming languages – it is a very overloaded word.

Does "safety" mean memory safety? Does it mean that things like OOB array access trap at runtime? Or should they return some kind of optional object to prevent trapping? Does it mean that it's possible to recover from every kind of exception? Does it mean that the language APIs make it difficult to get confused (I wouldn't think so, but the author's point #4 seems to make that case)?

As a concrete example from this article, take #3: "Java lacks null safety." That's only true if you consider throwing on an unexpected null value to be unsafe. Why is trapping (or catching the exception) here a quality of an "unsafe" language, when #1 said Java was unsafe because it " _does not_ trap overflows" (emphasis mine)?

I think any conversation of safe vs. unsafe needs to define in specific terms what "safety" means in a given context.

Are there things that everyone can agree are unsafe? Absolutely. But then there's a sea of gray-area which seems to shift depending on the context.

<comment><USER3> agree, I think there is a massive distinction between a buffer overflow, which can end up rewriting memory of the stack vs an integer overflow, which might cause the value in the specific segment of allocated memory to represent a different value. Yes, java has some behaviors which are not ironclad safe, but you have to recall it was designed in the world dominated by C/C++ at the time. Certainly modern attempts such as Rust and Go should have learned a thing or two since.

At the end of the day, most of the unexpected/nasty behaviors of java dont fall to the issues listed in the article anyways, except maybe data races (even there, I was pretty sure there were solutions, just maybe not native to the runtime).

<comment><USER2> Even more than the divide between older & more modern languages, I think specific context is key.

I talk to lots of app devs who think that array indexing isn't "safe" in languages where OOB will trap – because for lots of UI operations (say, the user selected item #5 and our local datastore thinks there's only 4 items), the answer can really be to tell the user something went wrong, reload the UI, and try again. That's what "safety" to them.

I hear related perspectives with services – where devs understand that if they're doing OOB array access, it's a bug and needs to be fixed. But if that bug traps the process, now there's a potential DOS attack vector. They want some way of throwing away an invalid execution environment, but return to a known-good state without respawning.

Is Java a safe language? I think you have to start by asking, "in what context?"

</comment></comment></comment><comment><USER4> Java is _memory_ safe. You cannot write a buffer overflow in java. When people say java is a "safe" language that's usually shorthand for "memory safe"

<comment><USER5> What's NullPointerException if not a buffer overflow?

<comment><USER6> Its more like a software interrupt that prevents the bytes in memory being read or executed. That's a level of safety over what you get in C, where a buffer overflow can lead to remote code execution or data leakage.

</comment></comment></comment><comment><USER7> The best part of this article is one can you use sed s/Java/$atop5tiobe/g and nearly everything still true.

</comment><comment><USER8> Regarding #4, I don't write Java at work, but don't people use IDE to write them? It's easy to check the parameter order with it. (When I used Netbeans for C programming, the hints that automatically come out really helped me a lot)

<comment><USER9> Yes, most Java IDEs tend to show the argument name in functions to get past this.

</comment></comment><comment><USER10> Man. I've been working in Flow/TypeScript for the last couple years, but for a long time my comfort zone was Java. Now I can't imagine going back to a world where every non-primitive type declaration was potentially null, and there was no way to mark it otherwise. Who ever thought JavaScript would end up having a more type-advanced ecosystem than Java?</comment>


Netflix admits to throttling video for AT&T and Verizon customers - <AUTHOR> http://www.theverge.com/2016/3/24/11302446/netflix-admits-throttling-video-att-verizon-customers <comment><USER2> Doesn't bug me as much as the Netflix attack against VPNs - which is akin to asking users to turn off their firewall or AV nowadays.</comment>


uiGradients – Beautiful coloured gradients - <AUTHOR> http://uigradients.com/ <comment><USER2> These are pretty and simple. Bookmarked for future use.

It was only 15 days ago when I changed the background in my app to use a gradient [1], and I still think it makes it look much nicer.

[1] [https://github.com/shurcooL/Conception- go/commit/92ed6d952f0...](https://github.com/shurcooL/Conception- go/commit/92ed6d952f0eca7ebd7d817eb52aa745216620b5#commitcomment-7501312)

</comment><comment><USER3> Yum! There are some really great-looking gradients here. I would love to have an easy way to see them at different scales, though. I'd want to see, for example, how a gradient that looks great over the full width of the browser window looks as the background of a smaller element.

</comment><comment><USER4> FYI, If you click the "Add Gradient" button while the "Get CSS Code" dialog is still visible, the "Add Gradient" dialog will pop-in behind the css dialog making it not visible.

</comment><comment><USER5> I see lots of banding, should I check my display or is that normal?

<comment><USER6> Check your display - no banding here.

</comment></comment><comment><USER7> Really simple to use - nice job. Maybe a way to throw in a sample page with some different text/typography/colors/sizes so you can really see how it would work.

</comment><comment><USER8> The first one I landed on was called "Influenza". Not sure about that name. But I like the colors.

<comment><USER9> In Italian it's either influence or flue. You pick :)

</comment></comment><comment><USER10> Startup like template become every day more generic.</comment>


Show HN: Ranking Your University Using PageRank on Wikipedia - <AUTHOR> http://blog.argteam.com/coding/university-ranking-wikipedia/ <comment><USER2> It would be interesting to compare your ranking to that obtained by simply sorting by the number of alumni with their own wikipedia articles.

</comment><comment><USER3> Heh, this is pretty interesting -- with the caveat that this really only makes sense as a ranking for _research_ institutions (which I think the author addresses quite nicely in his definition of 'contribution to world knowledge'.)

Related note: at what point do we expect to see things like Udacity and Coursera to appear in the USNWR college rankings?

<comment><USER4> I've actually computed a PageRank vector for all articles in Wikipedia. If you are interested, Coursera is about 0.0013% of Harvard which would put it very close to the bottom of the ranking.</comment></comment>


Why Your Ad Blocker Doesn't Block Those 'Please Turn Off Your Ad Blocker' Popups - <AUTHOR> https://motherboard.vice.com/en_us/article/j5zk8y/why-your-ad-blocker-doesnt-block-those-please-turn-off-your-ad-blocker-popups <comment><USER2> Isn't it obvious why? The website has detected the ad blocking and is crippling its functionality somehow. If the accompanying warning is suppressed, then the user doesn't know.

The fix for it would be to do ad blocking which is not detectable. That is impossible, since ads are something that the browser basically pulls from the site (or its associated advertising domains); you can't hide the fact that you're neglecting to access ads (unless you wastefully access them and then just hide them from view on the client side, which defeats the bandwidth- saving aspect).</comment>


Deutsche Bank completes cloud computing overhaul - <AUTHOR> http://www.computerworlduk.com/news/cloud-computing/3322339/deutsche-bank-completes-cloud-computing-overhaul/

<comment><USER2> > it runs on a network with 10 GB switches.

Why is this here, anyway?</comment>


Top trending YouTube video yesterday claims Florida students are crisis actors - <AUTHOR> https://www.cnbc.com/2018/02/21/fake-news-item-on-parkland-shooting-become-top-youtube-video.html <comment><AUTHOR> The video had 200,000+ views on youtube, 100,000+ shares on Facebook.

The tools we in the technology industry have built are undoing a millenia of societal progress towards structured and factual debate. Utter panic wins the day, Googles top minds clocking in each day to ensure the next suggested video will enrage and outrage, truth be damned, all to keep eyeballs pinned and share buttons clicked..</comment>


New data shows wearables are no longer just for the worried well - <AUTHOR> https://blog.cardiogr.am/new-data-shows-wearables-are-no-longer-just-for-the-worried-well-f4f1833dfbd <comment><AUTHOR> Let me know if anybody here has questions!</comment>


Ask HN: Why is there no social media all in one/aggregator apps? - <AUTHOR> <comment><USER2> There is. [http://fraidyc.at/](http://fraidyc.at/)

<comment><AUTHOR> Thanks! Any options optimized to mobile?

<comment><USER2> Not yet. I am hoping to work on this over the holiday.

<comment><AUTHOR> Let me know how it goes/if you need any help (I design buildings but can also do a little front end ux and engineering)</comment></comment></comment></comment>


Zig: a system language which prioritizes optimality, safety, and readability - <AUTHOR> http://ziglang.org/ <comment><USER2> Almost half the comments here are just to remind everyone that C can/will never be replaced. Is that really the most insightful we can be? Is HN so pedantic now that we can't analyze an interesting language idea, but just nitpick at its existence?

<comment><USER3> My plan to replace C is simple and pragmatic.

1\. Make a language and compiler that fills the same niche as C but does it significantly better, taking into account all the lessons we've learned in the last 44 years.

2\. Make a build tool that competes with autotools, cmake, make, etc. Similar to Python build.py, you'll have a build.zig, import a library and use it. The library does everything configure/make does except better.

3\. Package management on par with NPM and Cargo. Minimal overhead to publishing reusable code. Although I don't plan to have a central repository, rather the ability to put a URL or source control URL with a hash.

4\. Zig can import and export .h files, and you can target .o files that are compatible with the rest of your C codebase.

5\. Now there is minimal cost to replace bits and pieces of your codebase with Zig.

<comment><USER4> 1-3 are a _tremendous_ amount of work, especially if you want to replicate "everything" that automake does.

<comment><USER5> You don't need to replace everything that automake does. 90% of it is obsolete, and 9% only applies to weird C compilers.

</comment></comment></comment></comment><comment><USER6> Interesting language. Somewhat reminds of me "ooc"[0], though I believe ooc is ref-counted/garbage-collected (? I think. I can't remember, been a while since I've touched it); but being able to easy use C libraries from a relatively low-level language that has nicer high-level constructs is still a beautiful idea, in my opinion.

The language I'm using these days for that exact feature set though is Nim[1] -- being able to use {.compile.} pragmas and bring in header/source files, along with the great C type support is wonderful; but again, garbage collector (albeit one that can be tuned and/or turned off). Zig seems to be targeting the "true C replacement" niche, which I'm going to have to keep an eye on!

[0] [http://ooc-lang.org/](http://ooc-lang.org/)

[1] [http://nim-lang.org/](http://nim-lang.org/)

</comment><comment><USER7> Once you've made the decision to leave C for a systems programming project, why would one not just go over to Rust?

<comment><USER8> Rust? Maybe. But then, why not Go or Swift or Lisp? Personally, if I were to be expelled from C/C++ paradise, I would try Oberon - the only language I know that can compete with C in its simplicity and, despite normally being perceived as garbage-collected, the ability to serve as a truly systems programming language.

<comment><USER9> As far as vs Go or Swift or Lisp, Rust is much "closer to the hardware"(as discussed in other threads nothing is really close to the hardware anymore) than the other languages, go and most lisps use GC which causes problems in many systems language situations, and last I heard swift still has lackluster cross platform support.

I don't really know anything about Oberon so can't speak to that.

P.S. Personally, all my hobby projects are in lisp. I write applications though, not system stuff.

<comment><USER10> Oberon was used for writing a complete graphical workstation OS used during the mid-90 at the ETHZ in Switzerland.

It was a language and OS, following the same spirit of Xerox PARC OSes.

</comment></comment></comment></comment><comment><USER11> This is interesting from a technical point of view, but looking at the Hello World example [0] really makes me wonder... who wants to write code like this? I have been a touch typer for half my life now, but things like

> %% unreachable{};

> main(args: [][]u8) -> %void

really make my fingers and eyes itch.

[0] [https://github.com/jmi2k/zig- playground/blob/master/src/hell...](https://github.com/jmi2k/zig- playground/blob/master/src/hello_world.zig)

<comment><USER12> Try that on a nordic keyboard:

      % - SHIFT + 5
      { - ALT + 7
      } - ALT + 0
      ; - SHIFT + ,
      ( - SHIFT + 8
      : - SHIFT + .
      [ - ALT + 8
      ] - ALT + 9
      ) - SHIFT + 9
      > - SHIFT + <
      % - SHIFT + 5

Just for the bit you quoted.

</comment></comment><comment><USER13> This man is a prolific genius.

[http://genesisdaw.org](http://genesisdaw.org)

[http://libsound.io](http://libsound.io)

[http://groovebasin.com](http://groovebasin.com)

<comment> a-nikolaev Yeah, he is awesome~ cannot upvote this twice. And I think, his design decisions are very clear and straightforward too.

</comment></comment><comment><USER14> I don't know. C is very close to the hardware, and it's pretty portable, too.

I'd suggest doing what some other languages do, and get yourself to the point where almost all of the code for Zig is written in Zig.

In other words, you'd first write a `microzig` that's written in C++, and microzig knows enough to make `minizig`, which knows enough to make the rest of zig. This is what Perl does, and I expect other languages do the same thing.

On the other hand, zig is supposed to be able to cross-compile really well, so maybe you can skip that: Have version 0.9.9 be the last version written in C++. Then, for version 1.0, re-write the entire toolchain in Zig, and use the 0.9.9 compiler to compile Zig 1.0. At that point you are in full dogfood mode.

Finally, since it's called Zig, I get to close with this sentence: "You have no chance to survive make your time."

<comment><USER15> > C is very close to the hardware

At this point, I'd more say that the hardware does an awful lot of work trying to look like it's close to C.

<comment><USER16> It's an interesting phenomenon, specifically how processor companies (erm, Intel), who make "general purpose" CPUs, have clearly made trade offs to optimize for OSes that behave like UNIX or Windows varients!

<comment><USER17> Well, in fact, Intel and all the other major makers spend a huge amount of effort benchmarking important workloads. It isn't a decision to optimize for Unix or Windows, it is a decision to chase dollars. They will optimize processors for your favorite workload, too. Just demonstrate how many millions of dollars of business your workload represents, and create some sound benchmarks for it. Easy.

<comment><USER18> Any information on how many millions before a workload becomes interesting to Intel/AMD/Nvidia?

</comment></comment></comment></comment></comment><comment><USER19> Well I am impressed. And I am very glad to see more and more languages in this space. I particularly like that Zig seems to be minimalistic -- a lot more fun to look at (for me) than C++ or Rust.

But I didn't see anything in Zig similar to Rust's lifetimes. Well it's nice to be rid of that complexity, but I don't see how you are going to do C-like pointer stuff safely without them.

Can anyone explain what these languages (e.g. Zig, Myrddin, Nim) do instead?

<comment><USER20> Nim has a GC.

Myrddin doesn't, but I can't quite remember what it does for safety, if anything. The language spec does say "pointer arithmetic is not allowed."

For Zig, see here: [https://news.ycombinator.com/item?id=12380078](https://news.ycombinator.com/item?id=12380078)

</comment></comment><comment><USER21> > Maybe type instead of null pointers.

It's often a bad sign when a language advertises this high up on its features list. It means that they didn't really get the true takeaway of the Maybe type (which is that you should support algebraic data types to properly constraint data to valid states), but instead saw a single specific use case of ADTs (Maybe) and thought that's all there was to it.

I've run into this with Java 8. Optional is pretty common now and has eliminated the need for the null pointer in much of everyday code, but they still don't have something like Either to eliminate the need for exceptions. Maybe is extremely useful, but it's a small fraction of the usefulness you get with true ADT support.

<comment><USER3> Zig also has algebraic data types.

<comment><USER22> Are they ML like ADTs with pattern matching? That would be awesome.

</comment></comment></comment><comment><USER23> Syntax looks very Rust-inspired, but it lacks Rust's OCD. I also catch hints of other syntaxes, like Ruby/Smalltalk-style block parameters, and a defer very much like go's.

I find it interesting that it implements generics by passing types as normal arguments. Say, `list(i32, 1, 2, 3)` rather than `list<i32>(1, 2, 3)`.

<comment><USER24> i _love_ this

</comment></comment><comment><USER25> I can't seem to find any details on safety other than

> Safe: Optimality may be sitting in the driver's seat, but safety is sitting > in the passenger's seat, wearing its seatbelt, and asking nicely for the > other passengers to do the same.

Is Zig memory-safe? How? (Specifically, is there some useful safe subset ignoring the obvious FFI and "explicitly unsafe operations" exceptions every language gets?)

If it's not, is that even a goal?

<comment><USER3> It's not memory safe.

There is some compile time safety and some runtime safety, but it's not comprehensive.

Nullable pointers are handled by the type system at compile time.

Integer wrapping (signed or unsigned) will crash at runtime, unless you use explicit wrapping operators.

Array out of bounds will crash at runtime for slices.

There is no direct pointer arithmetic, but you can convert a pointer to a slice, and then index into the slice (which has array bounds checking). This is an example where the language is unsafe but it sort of guides the programmer into writing safe code.

<comment><USER25> Not being memory-safe is a bit of a bummer. Do you have a story for taking advantage of all the tooling thats been built up to defend against C's pervasive unsafety? Sanitizers being the most notable.

On balance even without them this'll _probably_ be safer than C (as long as you're avoiding like, 90% of its pitfalls).

Either way, hope this works out for ya!

</comment></comment></comment><comment><USER26> How is the goal of readability being addressed? I didn't find it particularly readable. Basically it's C with better types.

A few suggestions about the syntax, based on what many languages did in the last 25 years.

1) No mandatory () around conditionals. Make {} mandatory even for one liners instead. They remove bugs and are a common suggestion in the style guides of several languages.

2) The multine string syntax is verbose and uninviting. Use heredocs or a string delimiter reserved for that purpose.

3) Try to do without the ; line terminator

As a huge bonus, to reduce clutter, try to implement automatic import. I don't know of any language doing it, it's IDE territory right now (or editor's [1]). Still it's very useful because there is little as boring as going through a long list of imports at the beginning of each file. They should be there only when there is an ambiguity to resolve.

About readability, those {var v; while (cond) {}} blocks in the examples are puzzling. Finding a }} alone on a line was an "is this a syntax error?" moment, or just bad style.

Anyway, it seems to have generics so it's already ahead than Go, which seems to be stuck in the 60s regarding this feature (they've been pioneered by ML in 1973 according to [2]). For the rest, it's in the average of what we've seen in the past decades, so not shiny but not bad. Plenty of successful languages are like that and maybe it's a reason for their success: being average they don't scare away people. I'm thinking especially of Python, which smells oddly of C with its __underscores__ and the explicit self argument, reminding me of how we used to do OO in C passing around struct pointers (those structs were the objects, holding data and function pointers to methods).

[1] [http://www.vim.org/scripts/script.php?script_id=325](http://www.vim.org/scripts/script.php?script_id=325)

[2] [https://en.wikipedia.org/wiki/Generic_programming](https://en.wikipedia.org/wiki/Generic_programming)

<comment><USER27> One more syntax issue:

[http://andrewkelley.me/post/intro-to- zig.html](http://andrewkelley.me/post/intro-to-zig.html) shows the

        const number = parse_u64(str, 10) %% |err| return err;

pattern and then goes on to say that you can avoid repeating "%% |err| return err" all the time by writing

        const number = %return parse_u64(str, 10);

instead. I don't think that's particularly nice; it looks too much like "return the result of the call" when that's only what happens in the error case. I would have expected something more like this:

        const number = parse_u64(str, 10) %% return error;

where the compiler would turn "return error" into "|_some_var| return _some_var".

<comment><USER26> Agreed, %return is confusing and sends the reader down a wrong path.

Your last example could work if error is the default name for the error variable, which makes sense.

</comment></comment></comment><comment><USER28> Error handling mostly with error codes seems like an OK compromise for me since it doesn't require any dynamic memory allocation (like Gos error interfaces). I guess one would use some custom return type or a GetLastError equivalent if more details are required.

However I'm not sure if purely compiler assigned error numbers will work out for a systems language. Of course it works when you build the whole application, but if you build only a part of it (a library, an application that (dynamically) links against a library, ..., where do you get the information from which error codes are already occupied by them?

</comment><comment><USER29> One question: Why is Zig implemented in C++? What was the reason behind the choice?

<comment><USER3> It's mostly C, with some templates sprinkled in.

Zig depends on libclang and LLVM. Both of these are C++ APIs. Both expose a C API wrapper, but with not all features exposed that zig needs to use.

</comment></comment><comment><USER30> You lost me at hello world. Or maybe I should say you lost me @ %hello %%world. If you want to prioritize for readability the first thing you have to do is get rid of all that weird non-standard punctuation.

</comment><comment><USER31> The thing is, you will never replace C. Supplement it, extend it, yes, but not replace it

The fact is, C is still probably the lowest level HLL still used. It's the lowest level you _can_ be, while still providing the HL constructs we're all used to. There is always going to be code that wants or needs to be there. Code where anything further up either can't give the performance, or provides impedance to the design or actual goal.

You still want to replace C? Fine. What will you write your bootstrapping compiler in? :-D.

<comment><USER32> > It's the lowest level you can be, while still providing the HL constructs > we're all used to.

I disagree completely. A language much better than C will come along in its niche, and I'll be switching.

C isn't low level enough. It has too much undefined behaviour (and tries to be too portable), each instance of which denies you access to real machine behaviour. Signed ints don't even wrap around! Effectively, C does not even support twos-complement signed integers, as exist on all modern computers since decades ago, without a special compiler flag! You have to resort to tonnes of compiler-specific extensions to get things like leading-zero-count, SIMD, and computed-goto. Even with GCC's zillion extensions that were added for people who have to do _really_ low level work, C is still hopeless for writing maximum-performance VMs, that's why Mike Pall wrote the LuaJIT2 interpreters (one for each architecture) in assembly. Here's one of his explanations why C shouldn't be used for such a thing [1]. I've also tried writing a high performance interpreter in C, and I found that I wasted 80% of my time trying to get the C compiler to output the sequence of instructions I wanted. Next time, maybe I'll just use assembly and save myself a lot of trouble.

Secondly, C is not high-level enough. A low level language like C needs a powerful macro system to let you abstract away the details of your object system or whatever. C's preprocessor has many flaws [2] and is one of the worst in existence. A good macro facility allows compile-time generation of code in a readable (or at least type safe) way, like D and Lisp do. C and C++ users don't realise they have the preprocessor equivalent of a Blub language [3]. Sure, C++ is an extension of C with high-level features, and was a good attempt, but it's too complex and C++'s template meta-programming just about the only compile-time codegen solution worse than C's preprocessor.

[1] [https://web.archive.org/web/20160209102431/http://article.gm...](https://web.archive.org/web/20160209102431/http://article.gmane.org/gmane.comp.lang.lua.general/75426)

[2] Read any rant, e.g. [http://c2.com/cgi/wiki?CeePreprocessor](http://c2.com/cgi/wiki?CeePreprocessor)

[3] [http://www.paulgraham.com/avg.html](http://www.paulgraham.com/avg.html)

<comment><USER31> Yes, C's preprocessor is weak, but that's a quality of life thing, not a necessity by any stretch.

And as for C not being low-level enough, that was my point - C is as low level as you can be, before you become unportable.

<comment><USER33> > And as for C not being low-level enough, that was my point - C is as low > level as you can be, before you become unportable.

I don't think that's true. You can add first-class support for bitdata [1], much better than C's bit flags and portable, better support for alignment declarations, better/safer support for absolute addresses, native SIMD-like vectors [2], exposing arithmetic carry flags, and more without losing portability.

[1] [http://web.cecs.pdx.edu/~mpj/pubs/bitdata- icfp05.pdf](http://web.cecs.pdx.edu/~mpj/pubs/bitdata-icfp05.pdf)

[2] [https://gcc.gnu.org/onlinedocs/gcc/Vector- Extensions.html](https://gcc.gnu.org/onlinedocs/gcc/Vector-Extensions.html)

<comment><USER31> Well, now we know what to ask for in C17.

</comment></comment></comment></comment></comment><comment><USER8> C is beautiful in its way and it is rather minimalist from the syntax point of view (especially the pre-C99 variants). Judging by the code examples shown on the page, this new language has a pretty noisy (compared to C, downright ugly) syntax. Granted, it may be dictated by some logic and possibly even its inner beauty, but on the surface it does not seem to be much of an improvement compared to the languages we already know and love (or love to hate), including Perl and JavaScript.

</comment><comment><USER34> I would love to see a comparison to C, C++, Ada, Rust, maybe Cyclone. After reading the page I can't find an answer why Zig is better than any of established languages. (Haven't read comments yet)

Speaking of readability... well, still smells like C. And multiline string syntax is weird. :)

</comment><comment><USER35> While I find interesting the idea of a new C (instead of a new C++ like D, Nim, etc), I'm a bit sad that there is both the Zig AND the Jay projects.. It reminds me why Pascal lost (IMHO): too many incompatible Pascal 'clone'.

</comment><comment><USER36>
        return if (value >= radix) error.InvalidChar else value;

That is just painful to parse. Suffix-If sometimes makes sense and simplifies things, but it always makes code flow more difficult to understand.

<comment><USER37> I don't think this has anything to do with "suffix-if".

<comment><USER36> True, which only makes my poorly-targeted point on bad parsability.

Reading the code requires backtracking around a conditonal control statement, and in a format more verbose than ternary. Most places I've worked have bans or limits on ternary to single boolean cases for the same reason: It's hard for people to understand the control flow of operations around conditional assignment. A new language that lets you perpetuate painful code isn't helping as much as it could.

It's much simpler for people to parse the more verbose case with an IF and two return blocks, and the compiler shouldn't care since it can generate the same code either way.

<comment><USER38> I think that is quite subjective. I prefer this version with one return. I don't want more returns than necessary, and I want them as far up in the nesting as possible so they are easy to see. Returns are, after all, control- flow altering.

</comment></comment></comment></comment><comment><USER22> The first thing I would want to use something like this for is to write C API for a C++ library. Is that possible with the current state of Zig?

<comment><USER3> I think the best language to do that in is C++. You write a C .h file, and then a C++ .cpp file that implements the C functions using the C++ API.

Zig doesn't know how to use the C++ ABI. It's pretty complicated.

<comment><USER22> You are right that C++ methods need to be invoked in C++ code. However C container types are too weak/inconvenient to wrap C++ code. I am wondering if something like Zig can be used to create STL like containers that can be used at the API level?

</comment></comment></comment><comment><USER39> Intend in one hand, and ... well, you get the picture.

</comment><comment><USER40> Cool to see a fellow Recurser in HN!

</comment><comment><USER41> Modern amateur language designers usually are not aware of decades of research and breakthroughs in old-timer's languages, such as Algol, Scheme, Common Lisp, Standard ML and recently Haskell. They miss the beautiful specialized syntactic sugars in Standard ML (for defining and calling curried functions), Octave/Matlab matrix syntax, and the beautiful Common Lisp's looping and SETF macros, which inspired Python's for loop syntax for iterable collections and assignment operator overloading. Instead of spending time to learn and understand pros and cons and nuances they rush headlong to implement everything from scratch.

Really smart guys, however, are trying to leverage old-school languages, to climb on the shoulders of Titans.

David Moon created the PLOT language that leverages Lisps [http://users.rcn.com/david-moon/PLOT3/](http://users.rcn.com/david- moon/PLOT3/) , Rich Hickey did _almost_ the same with Clojure. Scala has been a leverage of Standard ML, similar to Ocaml. Now Swift is trying to distillate Scala, at least in terms of standard idioms and syntax choices. Julia has been build upon the big ideas from CLOS.

Python incorporated lots of good ideas and bits of syntax and managed _to balance the syntax and unify semantics_ and since 3.5+ earned reputation of a well-designed language (clear, balanced, complementing each other semantics from the Lisp world, and carefully chosen syntax). It is also famous for its _culture_.

So, for those who wish to change the world by developing a new language, it might be a good idea to look at Standard ML and its derivatives and try to relax some constraints and balance the syntax according to modern conventions.

I personally would prefer to start from David Moon's PLOT3 and, perhaps, try to marry it with some lightweight type-system based with optional annotations.

Btw, Haskell's choice of not mixing type information and function definitions and use annotations with its own DSL for types is a really big idea. It reduces cognitive load, makes code extremely readable, and in general, it seems, the best of both worlds. Python's optional type annotations are clever, but less elegant.

</comment><comment><USER42> Obligatory: why is Zig meant to replace C? Why is it a better replacement than Rust (when Rust is considered a C replacement)?

Interesting work nonetheless.

<comment><USER23> _I 'd_ rather use Zig than Rust because I wouldn't have to learn about how to work with Rust's memory management model. Even though I understand Rust at a technical level, actually getting my brain to work that way has proven difficult.

Being able to directly import existing C header files is also attractive.

Having said that, I'd rather Zig had been Go-inspired than Rust-inspired. Go plus Zig's approach to generics and error handling would be nearly perfect! (Notwithstanding that Zig's error handling is basically Rust's with added syntax sugar!)

</comment></comment><comment><USER43> Not with that logo it won't.

<comment><USER3> hahaha. I would gratefully accept an improved logo if anyone is willing to take the time to make one.

<comment><USER44> You still have a few hours to submit Zig into [https://news.ycombinator.com/item?id=12372118](https://news.ycombinator.com/item?id=12372118)

</comment></comment></comment><comment><USER45> Don't fix what's not broken.

<comment><USER46> Basically every deployed C codebase contains "undefined behavior".

<comment><USER45> Which is intended. Suggested reading: [http://blog.regehr.org/archives/213](http://blog.regehr.org/archives/213)

<comment><USER44> But I will still always argue that it's a bad trade-off to make compiler construction slightly easier at the expense of insecure code all over the place.

</comment></comment></comment></comment><comment><USER47> Is Zig compatible with C? No? End of the story.

Edit: I know that you can include a C header in Zig, and cross-compilation is possible and made easy. But you can't continue develop on current C projects if you switch to Zig. I guess that you have to change the Makefiles too.

<comment><USER23> But... Zig _is_ compatible with C. It goes to some lengths to make sure of it.

<comment><USER48> I guess @yyhhsj0521 means source compatible. Which was my thought too.

I mean, as source compatible as possible; which may not be much.</comment></comment></comment>


What fame and wealth do accomplish: they cure ambition anxiety. But that's all. - <AUTHOR> http://online.wsj.com/news/articles/SB10001424052702304418404579465244191453008

<comment><USER2> I feel like the author is making a hopeless attempt to get the (apparently young) reader to conform, not to current societal standards, but to those several generations removed.

How is it in anyone's interest to do that? They won't get any of the benefits of conformity with their peers, nor any of the freedom of self-determination.

>They have learned to reconcile faith and reason, yes, but beyond that, they persuasively convey ways of knowing that transcend intellectual understanding.

This part is a joke right?

Based on this article, I'm guessing that "The Curmudgeon's Guide to Getting Ahead: Dos and Don'ts of Right Behavior, Tough Thinking, Clear Writing, and Living a Good Life," is going to be trite, even for a self help book.</comment>


More Americans Are Underinsured – Axios - <AUTHOR> https://www.axios.com/underinsured-health-insurance-coverage-americans-641c603f-ce4e-4952-87fc-727dbfcfa609.html?stream=top-stories&utm_source=twitter&utm_medium=social&utm_campaign=limstream <comment><USER2> High Deductible Plans for the loss. For when "rational choice" means skimp on insulin and diet consulting because insurance will pay most of the cost of amputating your foot later.</comment>