In Defense of C++ - <AUTHOR> https://eklitzke.org/in-defense-of-c++ <comment><USER2> I've developed quite a bit in C, C++, Python, Go, Ruby, and Java/Coffee script and a hand full of others.

The thing is, of all the languages I code in C++ is my favorite. It is the most performant (using C where necessary), and is as easy to code in as JavaScript IMO. C++14 (and higher) feels like coding in Go or Python.

I feel most people don't actually have experience enough with modern C++ and are trying to use the 90's version of C++. The 90's version is awful, and even the modern has a few quirks. However, when you need performance and something less than C it's amazing.

<comment><USER3> C++11, 14 and 17 finally made me fall in love with C++. It's almost like having a nice and easy scripting language with the added bonus of static typing and a huge performance boost.

There are a few things that I'm still not quite happy with.

* It's still incredibly cumbersome to set up a project

* Setting up a proper build system is tedious, especially if you're targeting multiple platforms.

* I'm missing some "functional" methods attached to the collections, e.g. find, filter, map, some, each, ... Afaik some of them exist as functions that take 2 iterators and a lambda but that's just plain ugly and unreadable. Instead of

        std::find_if(list.begin(), list.end(), condition});

I'd like something like

        list.find(condition);

<comment><USER4> Have you tried CMake for setting up you C++ projects? It hide pretty much all the dirty details of find libraries and linking against libraries.

If you already have a compiler installed, you can go from nothing to knowing how to build a library, executable and an installer for multiple platforms in just a couple of hours with the CMake tutorial: [https://cmake.org/cmake- tutorial/](https://cmake.org/cmake-tutorial/)

<comment><USER5> I agree that CMake is better than handwriting a Makefile, it is still absolutely shit compared to Rust's build system or the straightforwardness of sourcing external dependencies with Maven or Gradle in Java.

If I want to use an external library in a C++ project, I need to:

* download it from the website / GitHub

* build it from source

* add the library into my CMake file.

Whereas in Gradle, I add a single line to one file and the library is installed on my next build attempt. Full stop. There are no more steps.

C++ makes it searingly painful to get a project going. I'm honestly afraid to add any new libraries to my projects because I know that (at minimum) that means I'm sacrificing an afternoon to resolving new errors.

<comment><USER6> Although I generally agree with you (CMake is a pain), I wouldn't say that this problem is caused by the language itself.

That you have to compile anything yourself is a byproduct of the fact that different platforms have different ABIs, combined with the lack of proper package management on platforms like Windows.

What I find the most enervating about CMake is that somehow everyone agreed (at least to some degree) to use the worst cross-platform build tool in existence. Instead of a build system based on solid principles we got a "hack your own build" starter kit in which you have to look for dependencies yourself ^1 combined with a build script language that is worse than the languages it set out to replace. How can anyone honestly be happy when switching from makefiles to this monstrosity?

^1 And no, the FindX scripts never work properly everywhere.

<comment><USER7> Personally, I agree about CMake and its horrible scripting language, and I like Scons a lot more. It's Python-based so it's easy to work with and flexible, and not nearly as ugly as CMake.

<comment><USER4> I think CMake took off, because it has no dependencies, works with any IDE and can be extended to do anything.

I have been in places where demanding python just wouldn't work. Either a specific version was needed for something else and managing the dependencies was a pain or we were already reliant on other scripting languages. I think this kills any other language as a build tool.

There are zealots for every IDE and some IDEs require special project files. If your build system doesn't seamlessly integrate most then it couldn't have made it. Scons never worked with IDEs I liked, Know how to get it cowkring with QtCreator? Other will demand vs2015r3 integration, how do you do that?

Then then there are the build systems you didn't mention, but the minimalistic ones. There was even one that was entirely stateless, but it was also too inflexible for most real builds.

CMake very carefully walked a thin line that dodged all these issues and the fact it is a giant pile of global mutable shared state simply doesn't for all but the largest builds.

</comment></comment></comment></comment></comment></comment></comment><comment><USER8> I think there exists both necessary complexity and unnecessary complexity. Necessary complexity is when the underlying system is genuinely hard and trying to simplify it causes nuance to be lost -- Rust and Haskell are good examples. Unnecessary complexity just stems from poor design and then perpetually trying to add features on top of the poor design and making it worse -- the classic example is PHP.

IMO, C++ has _both_ a lot of necessary complexity (due to its lofty goals) and a lot of unnecessary complexity (mostly due to the C back-compat). I think this is the root of a lot of the "C++ sucks!"/"C++ is great!" arguments; when people only see one half or the other.

My bottom line with C++ is that it tries and mostly succeeds to do a lot of hard things, but has questionable design decisions that make these things even harder than they need to be. For a while we just had to live with that because if you wanted a language that was both fast and high-level, C++ was the only game in town. I think that's no longer true, which is why I'm such a cheerleader for Rust: I see it as trying to have all the good things (necessary complexity) of C++ without the baggage.

<comment><USER9> _IMO, C++ has both a lot of necessary complexity (due to its lofty goals) and a lot of unnecessary complexity (mostly due to the C back-compat). I think this is the root of a lot of the "C++ sucks!"/"C++ is great!" arguments; when people only see one half or the other._

C++ is more like an ecosystem of about a dozen languages. You can divide it into 4 languages chronologically. You can add a lot more by categorizing by use. If you pick and choose properly, you can set up a subset of C++ that makes it a _great_ language. Half the computer programming managers out there have below average taste, however.

<comment><USER10> Any sufficiently large project that pulls in dependencies will likely involve you dealing with all 4 of them.

This is one reason why I doubt _adding_ more features to C++ (making it 5) is going to make the language any more pleasant to use (outside toy, one person programs).

<comment><USER9> _Any sufficiently large project that pulls in dependencies will likely involve you dealing with all 4 of them._

Which describes my current work situation. However, this would seem to imply that a startup or a small project would be able to set up a C++ project with a beautiful, cohesive subset of C++. Your point is something that people who are serious about language design for programming "in the large" should definitely pay attention to.

 _This is one reason why I doubt adding more features to C++ (making it 5) is going to make the language any more pleasant to use (outside toy, one person programs)._

How do you distinguish between one, two, three, or four person projects? Can you really make such a blanket statement about all the different possible codebases that exist? Methinks you exaggerate.

(And I say this as a former dyed-in-the-wool minimalist Smalltalker!)

<comment><USER10> I put the distinction at "more than 1" because that's the point where you need to deal with code that isn't your own.

(In theory of course your buddy could use a style and feature-set really close to your own and make it all a nice abstracted API so you don't need to look inside etc, but you get my point)

<comment><USER9> _I put the distinction at "more than 1" because that's the point where you need to deal with code that isn't your own._

You've never worked in a small shop where there was a good coding standard and everyone stuck to it? That sort of thing actually does pay off. I've seen this in my professional life.

<comment><USER10> We tended to use libraries or external dependencies, too.

(And when that was out of the question, C++11 and later usually were as well)

<comment><USER9> You should be able to build facades around that stuff, so your main codebase is all C++11.

<comment><USER11> That doesn't scale in big code bases, or in the typical corporate culture.

<comment><USER9> I know for a fact this isn't necessarily true.

<comment><USER11> I don't mean it never works, just that is it seldom the case.

I know C++ since the C++ARM days, it is one of the languages I like most despite its warts, teached it to first year students before C++98 happened.

Nowadays I spend my work hours in Java and .NET stacks, but still do occasionally use it, when needed.

I never worked in a company, with exception of my time at CERN, that actually followed C++ best practices.

So yeah, there are lots of companies making good use of C++, as proven by CppCon and C++Now talks, but they seem to be the minority, when you take into consideration the ones whose main business is not selling software.

At least I was pleased to see the BMW presentations at FOSDEM, where they mentioned moving from C to C++14, as a means to improve safety on car systems.

<comment><USER9> _So yeah, there are lots of companies making good use of C++, as proven by CppCon and C++Now talks, but they seem to be the minority, when you take into consideration the ones whose main business is not selling software._

I should be more thankful about my current job, then. I guess a good heuristic for judging a language is to go to conferences and see what is portrayed there, then "dividing by 8." That will get you to about the level of the average shop.

</comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER12> This is myopic in the characteristically self-undermining way that most of these defenses are.

I actually like modern C++ well enough for the niche described here; lambdas (and the control they offer over captured variables), type deduction, ranged fors and the like make it pleasant enough to write for being as performant as it can be. I've written many more lines of C++ than Rust. But it's still apparent that language-enforced invariants are quite a different species from conventions that will enable safe programs _if_ everyone uses them correctly at all times. You can _maybe_ guarantee that for a team, but can you guarantee it for several teams? Can you guarantee it for every external dependency?

I can imagine plenty of pragmatic analyses today ending up with C++ as the ideal choice of language, but the monomaniacal focus on Performance ignores ecological concerns like these and also mostly doesn't grapple with the fact that there's plenty of low-hanging fruit to get to performance-wise in any project before something like a fundamental 1.2x performance penalty on Rust's part really matters, especially considering how domain-dependent that number is likely to be. Pure speed is a pretty poisonous obsession in our field, IMO, and I think we've reaped the whirlwind for it already. It's time for a more holistic outlook.

<comment><USER11> As example, I never had any issue with bounds checking being enabled in all languages I used through my career.

Even in C++, I always had bound checking on my own classes and always make use of the validation flags in VC++.

It never mattered to the type of applications I was involved with.

<comment><USER13> I spent some time working on HFT systems. These things needed to achieve end- to-end timings (from a tick being DMAed into our memory to placing an order) around xx microseconds at the 99th percentile. The bulk of the code was written in a language that forced us to have bounds checking everywhere, and that was totally fine.

<comment><USER14> I'd assume most array boundary checks can be optimized away by a good compiler anyhow, assuming the array semantics allow that in the language in question.

</comment></comment></comment></comment><comment><USER15> I work on high-performance scientific simulation software in C++, and, I have to say, it works really well for us.

Our competitors do a bunch of code generation to accomplish the same things in Fortran that we do with templates and policy classes.

Sometimes, for shits and giggles, I'll prototype algorithms in Haskell or Common Lisp or what have you and, I have to say, the experience isn't really all that compelling, and this is without introducing MPI and all the associated headaches of working with MPI in something it doesn't support first-class.

<comment><USER16> I used to write scientific code in C++ too, but since a few years I've switched to Python+Fortran using f2py to automatically create bindings. Although there are a few drawbacks (different conventions in indexing arrays is the most annoying), I have not regretted this decision, python's ecosystem is incredibly large, and Fortran plugging Fortran modules allow me to optimize both speed and memory consumption efficiently. (But I eagerly await for the day Julia will be mature enough to allow me to switch!)

I only use Fortran just for low-level number crunching, and I must say I have yet to miss C++ templates here for this kind of stuff. I'm curious, what is your typical use of templates in your simulation code?

<comment><USER15> > what is your typical use of templates in your simulation code?

Apart from templating over floating-point precision, we use templates and policy classes to do a lot of the code reuse / flow control you'd use run-time polymorphism for, but without the overhead of virtual function calls. This is pretty useful for us, because our simulation algorithm has a lot of sub-parts that can be done in different ways. Rather than having a bunch of switch statements (or virtual function calls) in inner loops, we can have that switch statement once, in a factory object, and return instances of objects templated over the correct policy class so that we don't have to branch in inner loops.

One of our main competitors is on the Fortran / Python plan. Our application has, instead, a few proprietary input formats (one XML-ish, and the other binary to be used with a GUI). This has its drawbacks (i.e. rolling and using our own Python-based macro language for use with the XML-ish input files). The CEO tells me, though, that this is actually kind of a godsend from a support perspective, because there is a point where all of the customer's simulation logic is frozen into a text file, which we can then debug (this is in contrast to the Python / Fortran approach, where the customer's simulation logic may be very tightly coupled with our own code).

</comment></comment></comment><comment><USER17> I found C++ very complex and difficult to work with, though it is very powerful in terms of performance. There is also several years of libraries available in C++ that is difficult to leave behind.

If you are looking for something like C++ in terms of performance and has a nicer syntax, you should try the D programming language. It's very nice to use, as fast as safe C++ code (you can write unsafe C++ that is faster), has stronger typing, templates, mixins, and can interface with C /C++ libraries.

I've moved my personal projects over to D, I've started writing a game with OpenGL, SDL, ASSIMP, Devil and it's much easier than C or C++.

Some links for those who are interested:

Main website: [http://dlang.org/](http://dlang.org/)

Package manager: [http://code.dlang.org/](http://code.dlang.org/)

Some interesting documentation pages:

Interfacing with C: [http://dlang.org/spec/interfaceToC.html](http://dlang.org/spec/interfaceToC.html)

Interfacing with C++: [http://dlang.org/spec/cpp_interface.html](http://dlang.org/spec/cpp_interface.html)

Templates: [http://dlang.org/spec/template.html](http://dlang.org/spec/template.html)

Inline Assembler: [http://dlang.org/spec/iasm.html](http://dlang.org/spec/iasm.html)

<comment><USER18> How easily can you use D on something that's not x86? Is there decent cross compilation?

<comment><USER17> I've not used D on platforms other than x86 but I have heard cross compilation mentioned in the comments of some conference talks. I found this page which has the status of the LDC compiler on various platforms. It looks like it is still under development but I don't know recently that page was updated.

Status of various platforms: [https://wiki.dlang.org/LDC](https://wiki.dlang.org/LDC)

</comment></comment></comment><comment><USER19> I think C++ templates have hit a turning point where you can push much more static type information into your program and the compiler errors are increasingly useful.

For instance using the json for modern c++ json parser, you can write this:

myclass c = json_node;

and it compile time statically checks that a json->myclass deserializer exists, and gives sane errors if one of the (recursive) subfields of myclass does not have a json deserializer.

This makes json processing in python look like blood letting, and is close (until runtime) to the experience I'd expect from ocaml and other functional languages.

[https://github.com/nlohmann/json](https://github.com/nlohmann/json)

<comment><USER20> C++ type inference and first class lambdas and flexible typed tuples have made it possible to create a real useful type system into C++ programs now. It's quite pleasant.

But it robs a lot of much slower languages of their best value proposition. You can now do it all in C++ with correctness guarantees and still run 10x faster than most strong typed systems.

<comment><USER21> > C++ type inference

we prefer to call it type deduction not to upset type theory purists.

<comment><USER20> Steve Miller and Don Henley seem like such easygoing guys on stage. Surely the purists aren't so touchy.

</comment></comment></comment></comment><comment><USER22> _Recent languages like Go and Rust have taken over a lot of mind share—at least on sites like Hacker News_

C++ isn't "good" or "bad", it's just OLD (and is backwards compatible with an even OLDER language).

We are continually learning which language abstractions give a lot of implementation leverage (e.g. garbage collection), and which introduce unnecessary complexity.

Any new(er) language has the benefit of incorporating those learnings into the language design.

<comment><USER20> _a lot of implementation leverage (e.g. garbage collection)_

Putting garbage collection in that basket is controversial and lately the evidence is piling up against it.

Notice how new important growing languages like Swift and Rust don't have garbage collection and programmers don't miss it. GC is more and more restricted to low performance languages like Python, Javascript, and Ruby and a few specialized highly tuned and expensively engineered exceptions like the JVM and obscure LISP engines.

And if you've ever tried to program responsive, interactive, predictable, or time-critical systems, you know that GC is ruinous and awful for those applications. Meanwhile languages like Rust, Swift, and C++ can be used for everything from systems programming to games to low power mobile apps to scripting.

<comment> david-given Swift does have garbage collection! It uses reference counting, and AFAIK it doesn't have cycle detection, which means it's up to the developer to ensure that no cycles occur.

Regarding responsive interfaces: pure reference counting is particularly problematic for this, because an unbounded amount of work may happen every time an object's reference is decremented (because the object might be freed, which causes other objects' references to become zero, etc). If this happens inside a critical section Your Life Is Pain. At least you can control when this happens by taking and then dropping an additional reference. (See Obj-C's allocation pools.)

C++'s shared_ptr<>, BTW, is also reference counting, and suffers from the same problem. So it's technically correct (which is the best kind of correct) to say that C++ has garbage collection too.

<comment><USER20> Reference counting isn't garbage collection. It's the opposite of garbage collection. With reference counting, which is optional in C++ and can be opted out of in Swift, you keep track of your allocations and release them when you're done with them. With garbage collection an outside program decides when you're done with memory and deals with it for you on its terms.

It's true that there can be unlimited work done in reference counting. Of course, it's true there can be unlimited work in any function of any program. [0] With reference counting a programmer can fix the amount of work to be done and when in deterministic fashion. With garbage collection, there is no such power. The gc decides when it will work and you cannot control or predict the interruption.

You cannot produce serious interactive or time sensitive control software like that. You certainly can't write system software like that.

[0] [https://en.wikipedia.org/wiki/Halting_problem](https://en.wikipedia.org/wiki/Halting_problem)

<comment><USER11> > Reference counting isn't garbage collection.

Reference books in computer science, acknowledged by the experts in the field, happen to disagree.

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

<comment><USER23> How about: Reference counting is one form of garbage collection, but "Garbage Collection" without any additional qualifiers or context usually implies "tracing garbage collection", with or without the aid of other GC algorithms.

In common usage, I don't hear of languages like C++ described as a "garbage collecting language". That usually describes Java, Python, etc.

<comment><USER11> C++ has a GC API and a few dialects that support GC like C++/CLI.

Having RC library types doesn't make a language GC, because their correct use is not enforced by language semantics.

</comment></comment></comment></comment></comment></comment></comment><comment><USER10> Gah, another one of those promotional posts about Rust.

More seriously, the large enough Noto Sans font with a hint of extra weight renders so gorgeous in Firefox (it's even bearable in Chrome!). I wish all webpages were as readable.

As for the content, well, going back to: [https://eklitzke.org/c++-java-go- and-rust](https://eklitzke.org/c++-java-go-and-rust) I think the problem of the author is that he doesn't realize it's possible to do much better than C++. Claiming Rusts' ownership and borrow checking is exactly equivalent to std::unique_ptr or that Rusts' concurrency support is comparable to std::thread betrays very deep nativity, misunderstanding or just a mindset that can't see beyond what C++ offers.

</comment><comment><USER24> Templates only generate maximally-efficient code in theory. Generality kills them in practice; or, it makes the template code twisted to the point of insanity. For example, there is _no_ space-efficient way to model optional<T> for more than one value in a structure type; if you have several optional fields, it would make _much_ more sense to be able to track optional state as single bits of one field (say) but the class structure _prohibits_ such a space optimization and requires each template to track its own is-defined value. Pointless.

It is also essentially impossible to know that your code is well-tested: even when using something large and well-known like Boost, its authors _cannot_ know what will happen when you substitute in 4 of your own types (my bet is "result not quite working as intended; obscure bugs added").

I use templates but I am quite aware of code complexity and I essentially _stop_ when the templating goes too far.

Somewhere along the line, we seem to have gotten into a mode of wanting generic code at all costs. Why? It is _just fine_ to expose a few common specific methods when those are _very helpful and clear_ (such as classes exposing a "string value", "integer value" and "float value" instead of trying to provide some single partially-specialized template mess of a method that manages to _still_ not quite work right in every scenario).

<comment><USER25> _Somewhere along the line, we seem to have gotten into a mode of wanting generic code at all costs._

I know. Years ago I proposed a vector library for 2, 3, and 4 element vectors [1] as a standard. The immediate complaint was that it didn't use templates.

[1] [http://www.animats.com/source/graphics/algebra3.h](http://www.animats.com/source/graphics/algebra3.h)

<comment><USER26> The trouble is that a reasonable requirement such as single-precision floating point support would require a developer to copy/paste/modify hundreds of LOC. The choice is really fork, duplicate or template.

I don't blame glm for picking the latter. Every option is painful, but templates might be a little less so.

</comment></comment></comment><comment><USER27> Is there a "c++: The good parts" ?

One of the projects I'm working on could have just as easily been written in c++ instead of go.. except that in go starting the project and building it involved

      mkdir my_project
      # hack
      go build

I wouldn't even know where to start to write a simple c++ server that uses zmq and slings json around. How am I supposed to handle dependencies and vendoring?

As much of a PITA it is trying to learn rust, getting the toolchain working and starting a new project was not one of the issues I ran into.

<comment><USER28> Have you read Effective C++ & More Effective C++?

That's a start for what you want.

<comment><USER29> I think you mean "Effective Modern C++". The two you mention predate C++11.

[https://www.amazon.com/Effective-Modern-Specific-Ways- Improv...](https://www.amazon.com/Effective-Modern-Specific-Ways- Improve/dp/1491903996/ref=pd_bxgy_14_3?_encoding=UTF8&psc=1&refRID=CJT3K27NC7A692DCXP46)

</comment></comment></comment><comment><USER30> From a practical point of view, in many cases the performance critical sections are tiny compared to the rest of the codebase. Imposing such a cognitive overhead on the programmer when 90% of the code are executed once a second just to make those 10% really really fast, and then screaming "performance!!!" is not very convincing. Just use a high-level language and drop to C when needed.

Anyway, the author later says he just enjoys writing low-level C++ code, however unpractical this may be. In which case I don't really see the point of defending his choice.

<comment><USER31> But once you've optimized those sections, the rest of the performance problems are left scattered through your code. I've had to rewrite a system in C++ just a few weeks away from shipping because even after optimizing all the performance-critical sections, we still needed that extra 15% or so of "ambient" performance.

<comment><USER30> Sure, then you have a valid use case for C/C++ (even better, Rust!) But often people don't and still use C++.

</comment></comment></comment><comment><USER32> The point about templates being easy to optimize compared to other generics systems is simply wrong. Other generics systems provide more information to the compiler, so in addition to compiling faster and providing better error messages the compiler can use knowledge of specific type classes, interfaces, modules to optimize the implementation of. For instance, Rust can optimize `type NonZeroOption<T: NonZero> = Option<T>` to just the size of `T` because it knows that the `None` sentinel value is not used by `T`. You can also have nice features like GHC's rewrite rules which allow you to effectively tell the compiler how to optimize your types.

Most of the fast binary parts of templates is from stuff like specialization, which can be added to just about any generics system. Rust and Haskell both have it.

<comment><USER33> I don't think the T: NonZero bound is doing anything there: the size optimisation is done on the monomorphised/specialised type, not the generic one. In Rust, the concept of a generic types only exist at compile time, and they have no layout. Of course, this is still an example of a generic systems that specializes for performance, in a language that isn't C++.

</comment></comment><comment><USER9> _This creates a feedback cycle where people are using C++ to get high performance, and that drives the language evolution towards confusing "features" (and idiosyncrasies) that are done in the name of making it possible to generate more highly optimized code._

You can replace C++ with <insert language here> and you can replace "language" with entire programming stacks. Large numbers of programming software toolsmiths have been laboring towards the wrong goals for the past few decades. We programmers are like old school computer hardware manufacturers hell-bent on delivering the highest spec numbers at the highest margins, while consumers were beset with poor quality, poor reliability, and experience degrading bloatware.

We programmers are particularly prone to inflicting ourselves with experience degrading bloatware, while ignoring our own particular human interface design needs. We need to stop emphasizing "sexy" things like raw performance and mathematically provable semantic guarantees and start looking at how we impact our experience while reading and debugging code. We need to start calling out toolsmiths who give us "power" at the cost of long startup _penalties,_ and unresponsive, unwieldy software tools.

</comment><comment> chaotic-good This article doesn't have a clue. For example:

> but many C++ programmers disable exceptions for performance

I have never seen a project like this for 10+something years. The only piece of code with disabled exceptions that I've seen was created for Atmel controllers. And in modern C++ exceptions is zero-cost. Your paying for exceptions only when they occur so, nobody is disabling exceptions now.

This is not the only line that bugs me but I don't have enough time for it right now.

<comment><USER31> There are reasons to disable exceptions aside from performance. Google's C++ style guide (which bans their use) discusses some of the pros and cons: [https://google.github.io/styleguide/cppguide.html#Exceptions](https://google.github.io/styleguide/cppguide.html#Exceptions)

<comment> chaotic-good I saw this first time many years ago. It clearly states that exceptions is a good thing but shouldn't be used in Google's projects because their code is not prepared for exceptions:

> On their face, the benefits of using exceptions outweigh the costs, > especially in new projects. However, for existing code, the introduction of > exceptions has implications on all dependent code. If exceptions can be > propagated beyond a new project, it also becomes problematic to integrate > the new project into existing exception-free code. Because most existing C++ > code at Google is not prepared to deal with exceptions, it is comparatively > difficult to adopt new code that generates exceptions.

And most importantly, I don't think that they're disabling exceptions using compiler flag. I'm sure that they just using error codes for error handling instead of exceptions.

</comment></comment></comment><comment><USER34> It's hard to enjoy programming in C++ because the compile times are so long. C++ has grown up a lot, and smart pointers, a flexible template system, and lambda expressions, help you get a lot done easily, but every time you code up a useful abstraction, you risk ballooning your compile time.

<comment><USER35> Yeah, this is the genuine pain point experienced by actual C++ developers. Though really only templates will kill your compile times; other modern features are pretty safe. Modules will help. Hopefully.

</comment></comment><comment><USER36> > a rather weak type system, one inherited with relatively few changes from C

I don't understand this statement at all. C is a much weaker type system than C++. You can do things in C that will never compile in C++, it is much, much stricter.

</comment><comment><USER37> > So if I try to use this template with the wrong type, after a bunch of > template and macro expansion the compiler will print out a cryptic error > showing the templated code and the failed type substitution.

This is one of the reasons why Andrew Sutton and Bjarne Stroustrup are trying to push C++ _Concepts_ since C++11 [1]. They should provide much easier to understand compile time errors when it comes to templates.

[1] [https://en.wikipedia.org/wiki/Concepts_(C%2B%2B)](https://en.wikipedia.org/wiki/Concepts_\(C%2B%2B\))

</comment><comment><USER38> C++ is an insanely versatile language, and since you can use any C library with "extern C", it has a huge amount of high-quality libraries available for it. ffmpeg, openSSL, webkit, Qt. the problem is there is not a cross platform package manager to manage these libraries, and manually downloading and compiling libraries is a hugely painful and error-prone process. it's so bad that big C++ projects like Firefox and Chromium basically write their own scripts that download and build dependencies, and simply commit the source code of the libraries they use directly into their own tree.

I believe there is some thought being put into making a C++ package standard [0], which would do wonders for the language. in my opinion half of the reason Node took off is because npm is so easy to use, and people are getting excited about Rust partially because Cargo is so well thought out. Now I might be wrong here, but I think if you took modern C++ (no raw pointer manipulation) and combined it with a good package manager, I think you would pretty much erase any advantages Rust offers.

[0]: [http://www.open- std.org/jtc1/sc22/wg21/docs/papers/2016/p023...](http://www.open- std.org/jtc1/sc22/wg21/docs/papers/2016/p0235r0.pdf)

<comment><USER39> Does this one-liner count as modern C++?

        const string& s = max<string>("a", "b");

It makes a dangling reference that will crash when accessed. In Rust that's impossible.

<comment><USER38> good point, I had never heard of that.

</comment></comment></comment><comment><USER40> Aren't most of the points raised in the article actually solved by Rust? Doesn't Rust have a much cleaner template/metaprogramming system?

<comment><USER41> Note that Rust's system is a generics system, and there's less metaprogramming that can be done by it. Namely, the property mentioned in the post where "So if I try to use this template with the wrong type, after a bunch of template and macro expansion the compiler will print out a cryptic error showing the templated code and the failed type substitution." does not exist in Rust, since you specify bounds in the API itself.

This is both a blessing and a curse. As a blessing, it leads to very neat, clean, APIs and you never have to worry about such template expansion errors. As a curse, some of the more complex bits of C++ metaprogramming (check out what people achieve with SFINAE) are not possible. I personally think the pros outweigh the cons, but many people from the C++ world really like the power of template metaprogramming in C++. Rust is planning on offering procedural macros which address some of the use cases, but not all.

</comment></comment><comment><USER42> One huge advantage of C++ is Visual Studio. Once Rust gets something similar I might switch for my personal projects.

<comment><USER43> Doesn't VS only support a really old version of c++?

<comment><USER44> No, they keep up pretty well with the C++ spec. [https://blogs.msdn.microsoft.com/vcblog/2016/01/22/vs-2015-u...](https://blogs.msdn.microsoft.com/vcblog/2016/01/22/vs-2015-update-2s-stl- is-c17-so-far-feature-complete/)

You may be thinking of the lack of full C99 support.

</comment></comment></comment><comment><USER45> A few things: 1) Writing concurrent code in C++ is exciting (this is a bad thing). Processors are not getting much faster in serial execution, but the number of cores are continuing to increase

More here: [http://joearms.github.io/2013/03/28/solving-the-wrong- proble...](http://joearms.github.io/2013/03/28/solving-the-wrong-problem.html)

2) Programmer time is (usually) more costly than anything else in your organization. I'd argue that for most organizations, they're not making enough money per unit of throughput to justify the excessive programming time.

3) C++ is not designed for operators. Rust has this problem too. Once you know how to inspect a Java, Erlang, or Go program, the tools become familiar.

<comment> Const-me First, OpenMP isn't that bad. Second, the author of the article you've linked forgot about another kind of parallelization, SIMD. Realistically, SSE and AVX instructions are only usable from assembler, C, C++, and Fortran.

Sometimes throwing hardware at problems don't work. Either because it's technically impossible (console games, mobile) or because you don't own the hardware (PC games, desktop software). For such products, either you spent "excessive programming time" programming C++, or you won't release any product at all.

</comment></comment><comment><USER46> > _C++ is what you get when, at every turn in the language design road, you > choose to take the path that leads to higher performance._

You have plenty of performance with C, and C++ is what you get when you enforce C compatibility at all costs, then tack on other stuff. The memory layout that classes and class hierarchies force upon you lead to sub-optimal caching behavior. Virtual functions don't have optimal performance, but they still made the cut. Pointer aliasing actually hurts performance as it prevents the compiler from doing optimizations.

I do agree with everything that was said in "The Joy Of C++", bonus points for acknowledging the Stockholm syndrome. However, pretty much all of it could be said about C.

<comment><USER47> > The memory layout that classes ... force upon you lead to sub-optimal > caching behavior.

Simple classes have the same memory layout as C structs, contiguous chunk of memory which means they are cache friendly.

<comment><USER46> No, they're not cache friendly. The problem is row-based vs column-based. Array of structs vs Structure of arrays. With arrays of structs/objects you get row-based access patterns. Especially for cases where you only want to access one or two columns, you always pull in everything else. [https://www.youtube.com/watch?v=rX0ItVEVjHc](https://www.youtube.com/watch?v=rX0ItVEVjHc)

<comment><USER48> Are there any popular languages that support SOA 1st-class? C++ is largely competing with GC languages where it is difficult to avoid separated heap allocations for every tiny bit of data.

<comment><USER49> While not 1st class, in D you can do a completely transparent library solution, because you can introspect the fields of the struct you want to be SoA and insert arrays of those fields in to the SoA'd type.

Á la [https://github.com/economicmodeling/soa](https://github.com/economicmodeling/soa)

</comment></comment></comment></comment></comment><comment><USER50> > Templates are objectively extremely difficult to understand and use > correctly

Really? Template metaprogramming is not the only use valid use of templates. Most time a simple <class T> is enough and that is already a huge improvement over C.

<comment><USER51> Even most meta programming is not extremely difficult, unless we're talking boost level stuff, and more importantly it allows you to do super powerful interfaces for your API that are trivial to use (the implementation might get complex but consumption shouldn't be).

Like say you have a collection of entities where each entity can have one or more components of different types. Now you want to find all entities with components A, B, C and the returned value should have typed references to components - it gets a bit hairy to implement but it's trivial to use and efficient.

</comment></comment><comment><USER52> what is with programmers and needing to defend a combination of syntax, semantics, and runtime? C++ is a programming language with advantages and disadvantages. end of story.

<comment><USER53> > C++ is a programming language with advantages and disadvantages. end of > story.

Sounds like the beginning of a story, during which you explain the advantages and disadvantages, determine where C++ is best used, and compare it to other options.

</comment></comment><comment><USER54> AFAIK C++ still doesn't have a finally construct for its exceptions. Are there any plans to introduce it? Is so, when does it land?

<comment><USER55> C++ does not need finally, so it would not make much sense to add it. RAII is superior and is what is used instead.

Finally would likely just encourage people to write really awful C++ code.

<comment><USER54> So are you saying that C++ has no plans to implement finally?

(also I totally disagree that RAII is superior to finally. Finally, being lexically scoped, is far simpler, far shorter and far easier to understand. [https://codecraft.co/2013/10/31/why-we-need-try-finally- not-...](https://codecraft.co/2013/10/31/why-we-need-try-finally-not-just- raii/) )

<comment><USER55> That article does not convince me, scope guard + lambda appears to work just as well as finally, and is actually shorter(see tianyuzhu's comment)

I do not know if anyone has proposed it for C++, but I would be surprised if it passed given that it doesn't accomplish much.

</comment></comment></comment></comment><comment><USER56> C++ is called a "bad" language by people who think go or JavaScript are "good" languages.

</comment><comment> Const-me Very close to my view.

Here's my blog post about that: [http://const.me/articles/why- cpp/](http://const.me/articles/why-cpp/)

</comment><comment><USER57> Templates: originally for generics, now misused for SFINAE and slowing down the compiler.

Copy-elision: the copy constructor is unneeded, we should be move by default.

Answer: Rust.

</comment><comment><USER58> I'm experienced in c++98. I feel c++now is a new language full of weird syntaxes. I mean, unnecessarily weird.

I don't know why so many languages support lambda nowadays. It looks so weird and unnatural.

I still have to use c++ in some projects, never for the new syntaxes, just for there are some libraries I must use.

<comment><USER59> Lambdas give you a (somewhat) saner syntax for

1\. Defining a function within a function.

2\. Capturing a function call for later use.

<comment><USER58> Couldn't it be some less weird, just like the anonymous functions in JavaScript and Go? Even the lambda in Java is much readable than c++.

It give me the feeling that, c++ gives every corner a special syntax, or c++ adds new features by adding new syntaxes, there is no the word "reuse" in the process of improving c++.

In go, anonymous functions and general functions and methods have no much differences. But in c++, lambda and general functions and class methods are too different. Using class methods as callback in c++ is awful.

C++1x features make c++ code less readable, for fewer and fewer programmers know every syntax corners in c++.

</comment></comment></comment><comment><USER60> C++ is usually a premature optimisation.

I would use it for something like the Unreal game engine, because I know that:

\- performance is important in much of the project

\- the problem is complex enough to require high level language constructs

But for most tasks, my time would be better spent using a high-level language and then optimising the hot spots in, say, C.

<comment><USER61> > \- performance is important in much of the project

At scale this always becomes true. C++ can be written with reference counting and other high level concepts with runtime penalties. When you need to optimize or scale, you will never need to look to another language. I do a lot of numerical computing in Python and often need to drop into Cython or C; in C++ this wouldn't need to happen. One the the main goals of C++ is that "there is no language below C++".

High level language constructs are always nice, and C++ has a lot of "zero- cost" abstractions, meaning you only pay for what you need. For example, an iterator in C++ can just be a raw pointer in the case of iterating over a vector, but it is more complicated for a std::map because it is backed by a tree. C++ is a high-level language, so I don't understand the argument that you would be better off splitting your stack between the "important" parts and the slow parts.

<comment><USER62> Overstated. There is a level below c++, namely assembly intrinsics. When it comes to simd code using sseN avxN you really do use them when performance is important. That's if you're staying on the CPU. Going massively parallel on a GPU? FPGA? C++ isn't as low as you go.

<comment><USER63> I'd have more time to optimize at these lower levels if I wasn't stuck babysitting C++ codebases to protect them from and fix their undefined behavior.

</comment></comment></comment></comment><comment><USER64> In my humble opinion, after C++ 17, C++ does not need anyone's defense. I had worked on infrastructure pieces in Google and Facebook. Given the scale of data, and number of machines, it would not have viable without C++. Consider running 10 times faster using C++ still consuming thousands of machines that would have been 10s of thousands of machines. However, if your application runs fine using any slower language still consume single machine, it might not make sense in that case.

<comment><USER4> "Need"... I hope.

We could make that sentence damning or glorifying, depending on the missing word choice and someone would argue with you about it, no matter what word.

</comment></comment><comment><USER65> If you're starting a new system-level project, you should be using C++ or Rust, not C and _certainly_ not Go (which was designed for kids to write microservices with; in other words it competes with Ruby and Node, not C++). A modern language should support static typing with parametric polymorphism and statically determined object extent for most objects (with well-defined extent for the rest). Rust also gives you statically determined object _access_.

<comment><USER66> How can you, knowing absolutely nothing else about the use case, suggest a solution? What if they're on an architecture where the libc++ or rust runtime is low quality? What if their application needs to be NUMA aware?

There are plenty of reasons not to use C++ or Rust. They are not magic bullets which solve all engineering challenges.</comment></comment>


Show HN: Ship Data Science, track, improve, and fix models in production - <AUTHOR> https://www.shipdatascience.com/

<comment><AUTHOR> Founder here, figured I'd throw it up to get a straw poll reaction of smart folks.</comment>


Ask HN: Working for yourself - <AUTHOR> Looking for some advice on how to proceed forward.
After a long time thinking about working for myself I took the plunge last year. When I started I thought it would easy to find a small niche/product to replace my salary.
But reality has been very different. I look for problems in various areas but as I find any small niche that is attractive I find there are 2 dozen competitors already operating in this space. Which leads me to abandon my current project.
After 1 year of self-employment, all I can show for few dozen excitements and demoralization. Nothing shipped.
I am reasonably confident to be able to build most things if I have the motivation (I have worked in one of the FAANG) and I see some path of it giving me sustainable monthly income.
Would love to get your perspective on this what I am doing wrong how can I course correct. <comment><USER2> Somebody at my local startup accelerator said it is better if there is competition in your market because that proves there is a market.

Sometimes all of the competitors suck. I've had the experience of seriously exploring a product space and discovering the problem is harder than competitors think.

Ping me if you want to talk more.</comment>


NH professor pushes for return to slow reading - <AUTHOR> http://finance.yahoo.com/news/NH-professor-pushes-for-apf-3681719430.html?x=0&.v=2

<comment><USER2> I remember "The Reading Lesson" by Stephen L Burns, published in Analog Science Fiction and Fact, in which there was a difference in the manner of reading. Some people read and retained, appreciating the word, and others were basically "Barking at Print," saying the words without any true internalisation or understanding.

I see that today with some young people, allegedly able to read, functionally "literate," but listening to them read out loud they are "barking at print," and when quizzed have no understanding of what they have just read.

It's not new, but it makes me wonder how we can help people to learn to read better.

The same goes to a greater or lesser extent for math.

</comment><comment><USER3> _he considered buying a collection of "one-minute bedtime stories"_

I realized I had a problem when I would not even have the patience to listen to an entire song on my MP3, always flicking through tracks after 30 seconds at most.

To counter this, I picked up a thick and difficult book to read in the evenings (Infinite Jest), and now own a collection of the Oxford University Press "A Very Short Introduction" series to read on public transport. I highly recommend these snippets of knowledge, perfect pocket size and always well written.</comment>


LinkedIn Upgrades iPhone App With New Inbox And Recent Activity In Profiles - <AUTHOR> http://techcrunch.com/2010/11/19/linkedin-upgrades-iphone-app-with-new-inbox-and-recent-activity-in-profiles/ <comment><USER2> I'd like to see LinkedIn come up with an app for the Android and for the iPad. It would certainly make it easier to reach out to my business network.

Brett Miller <http://www.customsoftwarebypreston.com/company></comment>


Long and short scales - <AUTHOR> https://en.wikipedia.org/wiki/Long_and_short_scales

<comment><USER2> Ohhh man this is hilarious! I used to say Milliard (minus the d) when I was a child to over exaggerate a number :D. I'm actually laughing right now because I used to think I made up that word.

</comment><comment><USER3> I'm curious how widely used this is. The article mentions that the short scale became official in the UK. Any UK hackers around know how common the continued use of the long scale is, both among scientists/engineers and among the general population? Is the short-scale near-universal at this point, or still ambiguous?

<comment><USER4> I don't know anyone who uses the long scale scientifically or colloquially in the UK except for the occasional out-of-date pedant. Maybe some of the older generation still think it's ambiguous, I think I remember one of my parents commenting on it about 10 years ago.

</comment></comment><comment><USER5> One way to hide all of the zeroes is to rename (reclassify) the currency denominations. See [https://en.wikipedia.org/wiki/Hungarian_peng%C5%91](https://en.wikipedia.org/wiki/Hungarian_peng%C5%91)</comment>


Ask HN: Examples of founders doing whatever it takes to fund their startups? - <AUTHOR> Repost since it didn't get much exposure last time.<p>(Original: https://news.ycombinator.com/item?id=14906251)<p>As most of us know, starting a company is a lot more difficult than the tabloids make it out to be. On top of that, getting proper funding is next to impossible. Airbnb founders created political themed boxed of cereal during the McCain-Obama election in order to keep the lights on [1]. What other examples like this are there?<p>[1.] https://www.wired.com/2017/02/airbnbs-surprising-path-to-y-combinator/ <comment><USER2> Chaos Monkeys by Antonio Garcia Martinez[0] contains the chapters about funding of the Antonio's startup AdGrok.

[0][https://www.amazon.com/Chaos-Monkeys-Obscene-Fortune- Failure...](https://www.amazon.com/Chaos-Monkeys-Obscene-Fortune-Failure- ebook/dp/B019MMUAAQ)

</comment><comment><USER3> Whatever people say about UBER and it's less than nice tactics the fact is that Travis Kalanick did whatever it took, short of going to jail, to make the company competitive. There have been other ride sharing companies but he's is the one that's on everyone's mind.

There's one example.</comment>


Consumer Trends That Destroyed Media's Business Model - <AUTHOR> https://mondaynote.com/the-consumer-trends-that-destroyed-medias-business-model-945941075557?source=rss----c537d80ed0a---4&gi=f3fd52688073 <comment><USER2> Interesting article on media business model. never really considered the change from print to media content as much because I grew up with media print my primary source of information which made this to be very eye opening.</comment>


Social Networking is Like Fast Food - <AUTHOR> http://www.jonhmchan.com/thoughts/2013/4/15/social-networking-is-like-fast-food

<comment><USER2> I'm trying to think of _any_ experiences visiting websites which I could equate to a memorable dining experience at my favorite restaurant. I can't.

So maybe the whole web is like fast food.

<comment><AUTHOR> OP here - so the experience may not just be about actually being on websites. The kinds of social technologies I'd like to see probably serve as more of a supporting foundation for social interaction IRL than an experience that lives on the web.

Things like online dating, Meetup, foursquare, are all sort of in this vein, but not quite. It's the kind of technology that creates memorable dining experiences with your friends - something like that.</comment></comment>


Ask HN: "Cloud" based phone system for call centre - <AUTHOR>

I've recently taken over responsibility for reorganising a support team and one thing that's clearly not fit is the phone system. It's decent for a normal office but doesn't have the things I expect from a customer support phone system. Basic requirements as follows:
1, More complex IVR capabilities to filter calls to appropriate people (based on language, skillset, next-best routing etc) 2, SLA, queue etc monitoring in some sort of way we can put on a screen 3, Historical reporting 4, Preferably some sort of API so we can scrape data and load into a datawarehouse for stat consolidation
Our current phone lines are all VOIP anyway so a off-premises/"cloud based system would be ideal. <comment><USER2> If your requirement is in India, you can check out <http://cloudagent.in> built on top of the KooKoo( <http://www.kookoo.in>) platform.

Disclaimer: I work for Ozonetel which has built these</comment>


10 New Points About The New Apple Tablet: To Be Announced in January 2010 - <AUTHOR> http://crenk.com/10-new-points-about-the-new-apple-tablet-to-be-announced-in-january-2010/ <comment><USER2> Depending on the cost, this might be an attractive alternative to buying a Kindle by using this iTablet with the app, Kindle for iPhone.

<comment><USER3> When has Apple ever made the cheapest anything?

(not to bash on them, I actually love their stuff)</comment></comment>


Good Software Takes Ten Years. Get Used To it. - <AUTHOR> http://www.joelonsoftware.com/articles/fog0000000017.html This is a very good article by Joel Spolsky that was written seven years ago (I stumbled upon it via dzone this morning).  It's still very relevant. <comment><USER2> The message that I took away from this article was that good software has to deal with the likely exceptions it will run into in the real world, using real world data.

When I built the first version of the Ambient Clock (<http://ambientclock.com>), I groveled through the vagaries of iCal implementations. It was a nightmare.

I breathed a sigh of relief when we decided to use GData: a nice, clean API. But what bit me next was the USER data that was in there. Weirdly formatted, strange timezones, oddball recurrences and other stuff. The nice, clean API can only hide you from so much.

My point is that it is hard to write software that deals with human-generated content, in some structured way. As soon as you hit actual people, you can assume that they'll do things differently than expected: using semicolons rather than commas to break up bands, using a different DATE format when specifying things...

I believe Joel's definition of 'good software' is software that has learned to deal. And so can be used in a vast number of situations, by a vast number of people.

<comment><USER3> The VisualWorks Smalltalk JIT VM is another example. It has been in development since 1989, and it shows. I can write an infinite loop that does nothing but allocate, slip that into someone's image, start it, and they wouldn't even notice!

</comment></comment><comment><USER4> Isn't it a bit ironic that Lotus Notes is given as an example to good software? I haven't met someone who doesn't hate it.

<comment><USER5> _I haven't met someone who doesn't hate it._

I certainly have. And it led me to a little theory: that Lotus Notes' value was in enabling non-programmers to build a certain class of apps. If this is correct, then its value was pretty big (think of spreadsheets). It also explains why programmers hate Lotus Notes so much; systems built this way get messy very quickly (again, think of spreadsheets). But to dismiss the value to users is missing something big and important.

In other words, this dispute about "is Lotus Notes good software or garbage" is beside the point, because it's based on two different definitions of "good software". Software that helps users get things done that they can't easily otherwise do is certainly good by their definition even if it's the greatest garbagey kludge ever known.

(But I never used Lotus Notes, or even, as far as I know, touched a computer that had it installed... this is just based on stuff I've been told.)

<comment><USER6> I read an interview with an IBM technical guy once who claimed that Lotus Notes was first and foremost a synchronization platform (desktop and server) and email was just kind of built on top of that..

<comment><USER7> Well synchronization is still a big pain (Exchange server, anyone?) so if that's the problem they solved, then they deserved success.

<comment><USER6> "The product was very far ahead of its time. It was the first commercial client/server product."

"During this time, the developers at Iris used Lotus Notes to communicate remotely with people at Lotus. Halvorsen said, "Simply using the product every day helped us develop key functionality." For example, the developers needed to synchronize data between the two different locations, so they invented replication. "This wasn't in the original plan, but the problem arose and we solved it," said Halvorsen."

From IBM's "The History of Notes and Domino" <http://tinyurl.com/2b8wxk>

"Inside Notes provides a single place where you can quickly learn about the architecture of Notes" <http://tinyurl.com/ytjkf3> [PDF]

Note: I love how IBM's web site uses the famed Notes Icon as it's little Website icon identifier :)

<comment><USER5> This is significant:

 _Simply using the product every day helped us develop key functionality._

The feedback loop of eating your own dog food is one of the greatest benefits a software project can have. Here the programmers weren't only users of the product, they were using it as an essential part of the development work itself. That's like putting steroids into your dog food and then eating it.

</comment></comment></comment></comment></comment></comment><comment><USER8> 7-year old article, although that doesn't invalidate it. I think what _does_ is that web development (particularly using frameworks) is much more tractable and probably more lightweight than creating an office suite or operating system.

<comment><USER9> I don't have any experience with Fog Creek products but their software should be 70-80% good by now if what he says is true.

<comment><USER10> It is 70-80% good. (FogBugz)

</comment></comment></comment><comment><USER7> Just remember, this is from the slow release-feedback loop of desktop software. The distribution costs and time made it hard to iterate quickly. Web stuff is much quicker, but I'd still hesitate to say less than 3-4 years.

(yes, something can get put out in 3 months, but rich, full software takes longer. pg was still working on Viaweb after Yahoo bought them)

</comment><comment><USER11> The only problem I find with the article is the paradigm of programming in Lotus's earlier years... manual memory allocation, static types, ... things have changed in the programming, not to mention in other areas like software as a service and it being free. I don't think this is accurate anymore

</comment><comment><USER12> I think the jump from 10-20 million may have had something to do with lotus being bought by IBM, giving it a big marketing push.

Also, if he really wanted to prove his point he could have pointed out that the development could be traced back to the early 70s when Ray Ozzie was working on PLATO

</comment><comment><USER13> I think what he meant to say is that good software has to go through a certain process before it becomes good. This often takes, lets say, 10 years.

Not all software will make it that soon. Some will make it more quickly. Some will never make it at all.

</comment><comment><USER2> Joel's using ubiquitousness as a metric of "good", not necessarily if it is liked.

<comment><USER7> And if you're running a software business, ubiquitousness = sales = successful = good. You can't care too much about some cranky geeks if tens of thousands of customers are paying you good money for the work you've done. (Don't take offense, I'm a cranky geek too :) )

</comment></comment><comment><USER14> This sounds like a Zuckerberg statement.... "Software gets good after 10 years.": "Advertising changes every 100 years."

</comment><comment><USER15> 10 year rule?

sry joels, doncha know that the singularity is near?

</comment><comment><USER16> I've rarely found blanket statements like this to be true. The exceptions so frequently outweigh the assertion.</comment>


Ask HN: Online Resources/Courses to Learn AR - <AUTHOR> Hi, I am looking to use the lockdown to learn AR and maybe develop some project.
What are some online resources to get started? Thanks. <comment><USER2> [https://next.reality.news](https://next.reality.news)</comment>


Why kids don't program - <AUTHOR> http://johnlawrenceaspden.blogspot.com/2009/11/behold-in-its-full-glory-program-that-i.html <comment><USER3> For me it was exactly the opposite. I started learning programming at 13 reading the zx spectrum manual chapter after chapter until I came to sin and cos which I did not know. My parents hadn't studied, so they could not tell me. Instead of just skipping that chapter, I gave up programming. Much later I studied economics. Working as an economist I discovered the fun of programming with visual basic, and then decided to become a programmer.

If in 1983 I could have googled sin and cos or read about it in wikipedia, I would have wasted much less time.

<comment><AUTHOR> That makes me feel really sad. My epiphany was your iron curtain coming down.

I can see how. In fact I had the same reaction initially (and my parents are graduates, but they don't know the first thing about maths, so they were no help to me either).

I have no idea why I wrote the program to plot a circle that made it obvious what sin and cos were.

In fact I think I might have misremembered my own story. I had a ZX81 first, and I don't think that had a circle function, so it may be that the ZX81 manual explained how you could use SIN and COS to do that.

But I think we can agree that google and wikipedia are wonderful things. The upcoming generations of programmers and mathematicians are going to be Gods. How could they not be with a library like that!

<comment><USER4> "The upcoming generations of programmers and mathematicians are going to be Gods. How could they not be with a library like that!"

...because they also have lolcats?

Seriously, there are a lot more distractions these days, too.

<comment><USER5> Not just LOLCAT, DailyWTF, etc. but also HN, Slashdot, etc. Not just I waste a lot of time reading the articles, I probably waste more on reading the comments... while keep delaying work at hand.

</comment></comment></comment></comment><comment><USER6> In reality, I'd wager there's a _lot lot_ more kids programming today than 30 years ago. How many people had a computing device at home back then?

This anecdote makes the point that a very specific kind of thinking was better suited by the tools of the late 70s, and maybe - I've never been much inclined towards it, so I dunno.

And what we consider 'programming' is blurrier than it used to be. Is HTML programming? What if you use a fancy editor like dreamweaver? Only when it becomes dynamic? Does CSS count? A lot of youngsters, when they aren't getting off my lawn, have done web stuff, and the fact that it's a gradual shift from being a user to being a programmer probably makes it even easier.

I find the whole premise of this blog post flawed. (Great Scott! Someone disagrees with someone else on the Internet!)

<comment><USER7> And I disagree with you here. Writing declarative HTML and writing a simple interactive computer game are two activities that could not be more different.

Like it or not, the act of programming has become much more difficult than it once was. 1988 I could reboot my Apple IIgs, hold down a couple of keys, and I could start writing a BASIC program immediately.

<comment><USER8> And in 1995, I could write interactive (quasi) graphical games on my TI-81. Without rebooting. At the time, a TI-81 was pretty fancy, but I've seen plenty that leads me to believe that nearly every kid today has a TI-83 for their math class. It's not quite basic, but it's certainly programming, and it's just as easy and accessible as an Apple used to be.

<comment><USER7> Kids are not fooled. Programming a computer and calculator are also not the same thing. While I enjoyed hacking on my graphing calculator as well, the limitations of the calculator (no color, small screen, no keyboard) made it fairly limited for learning any broader concepts about programming.

<comment><USER9> The point is access, not completeness. Kids have access to more devices that are easy to program, just less so their computers.

</comment></comment></comment></comment></comment><comment><USER10> It's actually fairly easy to do what he wants today.

        ipython -pylab

        [...boilerplate...]

        In [1]: n = arange(255)

        In [2]: plot(n, 88+80*sin(n*pi/128))

<http://imgur.com/oSd62.png>

As for the "imaginary diffusion equation" (I assume he means the Schrodinger equation), here is a simple program which solves it on the torus:

        from pylab import *
        from numpy.fft import *

        def freeSchrodingerSolver(input, dx, dt):
            np = input.shape[0]
            k = arange(np)*2*pi/dx   #Coordinate system in k-space
            k[np/2:] -= np*2*pi/dx   #FFT puts negative frequencies
                                     #on right side of array
            return ifft(exp(complex(0,-dt)*(k**2)/2)*fft(input)) / np

I really doubt it was easier to do that on a ZX Spectrum.

<comment><AUTHOR> Well, actually,

sudo apt-get ipython sudo apt-get install ipython ipython -pylab sudo apt-get install pylab sudo synaptic (<\--used it to find pylab packages) sudo apt-get install python-matplotlib sudo apt-get install python-matplotlib-data sudo apt-get install python-matplotlib-doc ipython -pylab

And then the program works.

Actually, thanks for that, I didn't know about that stuff, and it looks really useful. If I can figure out how to get the drawings to move then it will do what I want. (to visualize the action of unitary matrices on Hilbert spaces)

But my point was that in 1982, my non-technical parents bought me a computer and then I was away. A couple of months later I had an animated model of the solar system. And I hadn't read anything except the spectrum manual (and the equivalent one for the TRS-80).

I can work out how to do the above installation for my hypothetical 12 year old son, but my poor father wouldn't have had a chance. And I suspect that the same would be true for most non-techie parents.

And how is the hypothetical son supposed to go from the pretty blue curve created by the magic plotting program to an animated solar system?

I can't see how to make the graphs move. Perhaps it can be done. Perhaps it can't and I should use SDL instead.

The point is that it is not obvious to me. Whereas the equivalent questions were obvious to a child thirty years ago.

<comment><USER10> Regarding a minimal setup python environment, which requires nothing more than a newbie parent to download, PythonTurtle or Squeak is probably what you want.

I think the issue is mainly just lack of knowledge that truly newbie friendly environments exist. Perhaps the solution is simply better advertising of squeak, or perhaps having it come preinstalled (as OLPC did)?

Incidentally, the animation info you seek (admittedly, not suitable for newbies):

<http://www.scipy.org/Cookbook/Matplotlib/Animations>

Or, if you want to generate movie files:

        for i in range(numframes):
            [...code to make frame...]
            savefig("framedir/" + str(framenumber).rjust(8,"0")+".png")

        os.system("mencoder -ovc lavc -lavcopts vcodec=mpeg1video:vbitrate=1500 -mf type=png:fps=16 -nosound -of mpeg -o movie.mpg mf://framedir/\*.png")

<comment><AUTHOR> Thank you so much for that and for your previous post. Exactly what I wanted.

</comment></comment></comment></comment><comment><USER11> Probably tangential... I learned what sin() and cos() did experimentally.

There was a BASIC program in Creative Computing that used sin() to make a long snake of text scroll down the screen. So, in my mind, sin() and cos() were things that made wavy lines.

A little while later I was puzzling over how to draw a circle. I had this epiphany that the X component was drawing a wave, just like sin(), and the Y component was drawing a wave that was just out of phase. I went home and programmed it and it worked instantly.

We had a Britannica at home, so I finally looked up what sin() and cos() were, and the diagrams made it all obvious.

It's good that we now have Wikipedia and all, but kids today are still deprived of a computer that comes with a decent programming environment, that makes fun stuff like graphics dead simple.

<comment><USER12> And when kids download "decent programming environments" they have absolutely no idea how to use them. =/

That one comes from personal experience.

</comment></comment><comment><USER13> The crazy thing is, he just told the exact same story about beginning programming as I would tell. The only difference, is that I'm 21, and my first experience was drawing circles on a TI-83 graphing calculator in high school.

It has a graphing mode, where you can put in functions and it'll draw them for you. And it has a programming mode, with a very BASIC-like syntax that I wrote simple graphing programs, ridiculous text-based rpgs, and my own version of the oh-so popular Drug Wars.

Having no idea what a ZX Spectrum is, I can only assume that the likelihood of the author having one 30 years ago is about the same as the likelihood my having a TI-83 in high school, especially because the calculator was pretty much required for some of the math classes I was in.

<comment><USER14> You're right, they're pretty similar. The ZX Spectrum was a little personal computer, sold in Britain through the 80's. It was pretty cheap, probably the equivalent of $750-$1000 today. Certainly cheap enough for parents to buy for a bright young boy.

Since the ZX ran BASIC, programming for the spectrum and your TI-83 is pretty comparable, although your TI-83 was a bit more powerful. :)

<http://en.wikipedia.org/wiki/ZX_Spectrum>

</comment></comment><comment><USER15> I am the same age, and I had a very similar experience, especially with regards to the BASIC manual. I would just go through the list of keywords, A to Z, skipping the ones that didn't make sense at first, and then circling back and starting all over until I had them all. In a way, a _limited_ manual made it easier to circumscribe the problem, and gave my little nerdy self a "goal": Finish The Book.

I guess the same could be done with the information available on the Internet. If someone wants to learn javascript they have all the info they could possibly ever want. There are so many options now. But learning to program is a question of interest and determination, not availability of information.

</comment><comment><USER16> I don't agree that programming has gotten harder, I think it has become easier. What is harder now is finding material to learn programming that is simple for kids but also still "real" programming (not just game creation kits).

I wrote a freely available book called "Invent Your Own Computer Games with Python" and released it under a Creative Commons license. It's available at <http://inventwithpython.com>

I think Python makes a great (even superior) replacement for BASIC. Adding in Pygame, and it is much easier and fun to learn programming.

<comment><USER17> I looked over your book at some point and loved it. Thank you for writing this.

I prefer pyglet over PyGame. I wrote a tutorial for it in the style of your chapters 16-19. It's up at [1].

[1] <http://www.steveasleep.com/pyglettutorial>

</comment></comment><comment><USER18> About 5 years ago, in 7th grade, almost the exact same thing happened to me, but with a TI-83 graphing calculator. I would estimate that there are approximately the same number of kid programmers as there were. Modern PCs and macs don't come with compilers or interpreters, and there is no "command mode". Why would the ordinary kid ever open up cmd.exe, when everything you could ever want to do on a computer is on the web? I only learned TI-BASIC because a friend's dad is a hacker. He inspired me to check out the only book on programming at our school, which happened to be about BASIC. The truth is that, while kids are closer to computers than they were 30 years ago, they're not much closer to programming.

<comment><USER12> I started programming around 6th grade, and I am in 11th grade now. I started because one of my "really smart friends" was doing it. He started because his dad made his own linux distro .(That's a lie. I know his dad has made his own linux distro, but I honestly don't know why he started, but I am sure his dad is the cause of inspiration.) The point is that I am sure tons of people would love to learn to program if they are simply given the opportunity- the inspiration (and the tools).

Why would I be sure of this? People have come up behind me and asked questions like "Wow, that's a really cool word-like program. Where did you get it?" Of course I tell them I made it and almost always I get asked how. I've even given out a couple of programming "lessons". (That's a lie. I've given out hundreds of programming lessons, and I've written at least ten little programming manuals to help people begin to program.) However, the _real_ point is: If given inspiration, kids are very curious creatures and will start to program.

</comment></comment><comment><USER19> I had c-64 and one of the most frustrating memories from my childhood was that I couldn't get it to draw anything in a graphic mode. In manual the code to initiate graphic mode had error in it, or the manual was for different version of the computer, I still don't know.

Anyway - 8-bit computers were superb "teach-yourself-programming" machines, but I think novadays kids have internet access, so they will manage :)

PS. I would choose python + pygame to teach a kid graphic programming. It is simple, interpretted and has interactive console.

<comment><USER20> Graphical mode on the C64 was difficult, ZX Spectrum was much easier for that. C64 ended up being the better game engine, though :-)

</comment></comment><comment><USER21> <http://www.zxspectrum.net/>

</comment><comment><USER20> I wonder, is Logo still relevant for children (was it ever)? I know Netlogo or StarLogo are still in active use in academia (for artificial life/complex systems research).

I have been toying with the idea to write a Javascript LOGO for the Canvas Element. There used to be Online-Logo Applets, but I think they were all Java.

At least it might be a fast way to draw nice things programmatically.

<comment><USER22> This JS-based Logo works nicely: <http://logo.twentygototen.org/>

Here are a few programs I made with it (note that the default is to 'run normally'. You might want to click 'stop program' and then 'run fast'):

* Sierpinski triangle: <http://logo.twentygototen.org/83EGZPPC>

* Sierpinski carpet: <http://logo.twentygototen.org/4c5iy9iU>

* Sierpinski arrowhead curve: <http://logo.twentygototen.org/hYDSZt8h>

* Hilbert curve: <http://logo.twentygototen.org/CFyUSzqG>

* Hexaflake: <http://logo.twentygototen.org/AJeuVkKc>

<comment><USER20> Very nice!

</comment></comment></comment><comment><USER23> There are so many more options than when he was writing BASIC programs on a ZX Spectrum. Choose something straightforward and stick with it. Python is about as simple as it gets. PLT Scheme is also a great option, it has a fully self- contained environment that includes much better graphics options than BASIC did, and is well-documented. There are lots of others - this post has some good discussion on a similar topic: [http://stackoverflow.com/questions/950619/summer-holiday- pro...](http://stackoverflow.com/questions/950619/summer-holiday-programming- club-which-language-suits-best)

<comment><USER7> Having more options means you have to figure out what choose. That doesn't make it easier, that makes it's harder.

It's also important that there be a lot of reference materials which would be easy for a kid to teach him/herself with.

For example: [http://www.scribd.com/doc/200861/A-Touch-of-Applesoft- BASIC-...](http://www.scribd.com/doc/200861/A-Touch-of-Applesoft- BASIC-1986AppleIIc-IIe-IIGS)

This was the book I read when I was 10 years old. It was also easy to find BASIC code at the school library and in computer magazines.

How many current general computer magazines still publish useful bits of code ("How to access your mouse from Apple Basic", etc) ?

<comment><USER24> How many general computer magazines still exist?

The web has made printing code redundant. Why type it in when you can cut and paste?

</comment></comment></comment><comment><USER25> Nothing will ever stop a hacker from programming and figuring out a machine, especially age.

I started when I was a tot during the days of DOS on an IBM box. At least kids these days have the internet, we were left to fend for ourselves.

</comment><comment><USER26> I remember growing up I was playing on the Internet and found a 10 chapter book online for QBASIC. I printed it out and had it scattered all over the floor, and in no time at all I was writing code that actually did things. I had never written code before and I was in elementary school (9 or 10?).

Eventually this led to html, javascript, php, VB, C#, etc. Dad wasn't real thrilled when he realized I used all of the printer ink to do this, but I'd say it was a pretty good return on his investment.

EDIT: I'd like to play with BASIC again, anyone know of a way to do that on OSX? VM?

<comment><USER27> You should check out Chipmunk BASIC [1]. Nice simple BASIC interpreter that runs natively in Mac OS X and includes basic graphical functions.

[1]<http://www.nicholson.com/rhn/basic/>

</comment></comment><comment><USER28> It's important to keep in mind that one of the reasons it was "easier" to program back in the day is that you had so many fewer options. The flip side of not _having_ to install anything is not being _able_ to install anything. BASIC was cool, but once you hit its limits (which was very easy to do) you were kinda screwed. Sure, you could learn machine language, but that was a _lot_ harder than running Python or Javascript.

</comment><comment><USER29> This type of math-programming-graphics-game mind soup resonates with me very well.

I did mine on a TI-83 calculator, went to visual basic, and then C++/DirectX. Once I grasped sin/cos/tan, I created Microcosm (missle command, angles, rotation as my primary game mechanic due to my fascination of the power of trig, <http://arcade.connersc.com>).

I feel the same way. You put it in words clearly. :)

</comment><comment><USER30> I tried a few times to get into programming but the amount of institutional knowledge required was so off putting. Learning the languages and APIs isn't too hard but I found all the reference material didn't teach me how to actually solve problems. I suppose this is something you need a mentor or at least a strong background in legitimate computer science to understand.

</comment><comment><USER31> When I was a kid I did not know any adult programmers and thus assumed programming looked like the strange special characters you would get through alt + shift combos. This didn't scare me - it just upset me that I didn't know how to utilize it. If someone had shown me APL I would have been amped hahaah!

</comment><comment><USER32> Javascript is pretty much the new BASIC for kids these days.

      10 print "BAH"
      20 GOTO 10

      <script>
      for(i=0;i<100;i++) {
        document.write("BAH");
      }
      </script>

<comment><USER33> Barring grotesque hacks, Javascript (and the entire standard WWW stack) will neither emit sound nor write to a disk. Not to mention the inescapable "If InternetExplorer Then CrappyWorkaround" abominations which come with web programming.

</comment></comment><comment><USER34> I miss _why ...

<comment><USER35> Hackety Hack, like all of _why's projects, got adopted by someone else after his departure: <http://github.com/steveklabnik/hacketyhack/>

Alas, it doesn't seem to be getting much activity.

<comment><USER36> It's true. A crazy series of events took lots of my time recently... including the launch of my startup. I'm planning on getting back into the swing of things with Hackety, though, as my local Ruby Brigade just started up, and I feel like I could get a decent helping hand from some of those guys. I'd love to not be the only guy doing something with it. I have one other core contributer, but again, he's busy as well.

Every project goes through slow periods. _why has some quite large shoes to fill.

<comment><USER35> Hey, that's awesome, I hope it didn't sound like I was bashing you for neglecting it or anything. _why seemed to be superhumanly productive, so I wouldn't expect any one person to keep up his pace. I'm just happy to see that his projects weren't abandoned, thanks to you and everyone else who took up the torch.

<comment><USER36> None taken. We actually had a discussion about this a week or two ago. I'm just glad that you linked to my GitHub. Thanks for still talking about Hackety.

</comment></comment></comment></comment></comment><comment><USER37> I have been looking at this for my 7 yr old son. Beyond school, his time is spent getting muddy on a soccer field, swimming, building dens, and generally racketing around with friends.

However, along with every other 7 year old, he want to know how things work. I am finding that many of my explanations get from A to B via "and at this point there is a computer that does ...". - Things: Microwave, car, alarm clock, phone, camera etc. and broader systems: exams, shops, banks etc.

I could explain things in terms of the model that is embodied in the computer, but that seems wrong - at least as the only explanation. If you pull it apart, you don't find the coresponding physical embodiment.

If he does want to dig further into this and explore how to make computers do things, I want to have a good set of resources to draw on - My current short list w/ comments:

\- Lego Mindstorms NXT

Start with the provided graphical environment, move on to one of the several text based development environments, eg: NQC, leJOS. He loves Lego, and I have already set up a mindstorms controller+psx joystick to give him a drive+steering component he can use in his own constructions. I find the graphical a bit cumbersome.

\- Nodebox (<http://nodebox.net/code/index.php/Home>)

I think it is great - python & easy graphics. I have already been showing off some simple drawing animations and fielding requests to: "Make it go the other way, go red, faster, jump etc." - Cool, but I am well aware the he'll get frustrated with syntax errors.

\- Processing (<http://processing.org/>)

Also, cool - not used it so much myself, and I am not sure I want to start explaing curly parens & semis, but it does lead into Wiring and Arduino. One thing I would really love for him to experience is making things w/ embedded cpus - even if it just simple things to spin motors and flash leds.

\- Scratch (<http://scratch.mit.edu/>)

Only recently found this. For me, the visual programming was way easier than Lego NXT. Going to have more of a play.

\- Nintendo DS homebrew

\- C64 - in the form of a C64DTV (<http://en.wikipedia.org/wiki/C64_Direct-to- TV>)

\- Usebox (<http://belogic.com/uzebox/>)

When I was mucking around w/ NDS homebrew I had him draw some characters, then we scanned them and displayed them as sprites bouncing around (one was under joypad control - no collisions or gameplay, maybe 20 lines of code)

My own experience was that making games was a very powerful motivation - <USER2> all these 3 provide a way into that - C64 & Uzebox would provide a similar experence to mine (well, I was a BBC fanboy, but anyway). Nintendo DS would be a bit more up to date, and would have some currency with his mates. Some way of targetting NDS from processing would be a cool halfway house.

Assuming he is at all interested, it will be interesting to see if any of this is appropriate. If not, well, there is another son - and maybe I'll just get stuck in myself.

</comment><comment><USER38> Teach children to draw on a canvas in javascript.

You can easily make a page with a javascript editor and immediate evaluation if you wish, and simplified api.

<comment><USER7> Someone should build a social and pedagogical programming environment for kids on the web. The main problem here is the frustrating fact that one stupid browser doesn't support an HTML tag that's now 4 1/2 years old.

<comment><USER39> There are some very nice programming environments for kids. MIT Scratch (<http://scratch.mit.edu/>) immediately springs to mind, for example.

Any particular reason it needs to be web-based?

<comment><USER40> Yes, because every kid (at least in the 'developed' world) nowadays has web access but not every kid can install software on the machines they are allowed to use (for instance in school, the library or their parents' machine).

<comment><USER41> And, they can very easily show it to there friends, if it is in javascript. My niece loves designing webpages that she shares with her mates. Of course, getting her to program rather than put up pictures of twilight is another issue.

<comment><USER42> True. I guess these are the same two reasons anything needs to be web-based: (1)Easy to get started. No hurdles. (2) Sharing</comment></comment></comment></comment></comment></comment>


Redundant Variables Are Pure Evil - <AUTHOR> http://www.yegor256.com/2015/09/01/redundant-variables-are-evil.html?2015-35 <comment><USER2> For the example in the article, I think I'm inclined to agree. However, with something like

numIterations = 5

foo(numIterations)

versus

foo(5)

I think adding that extra variable greatly improves readability by removing the step that requires jumping to the function signature to understand what the integer argument is doing.</comment>


How to get into Y Combinator according to the founders that did get in - foti-panagio https://www.growthmentor.com/blog/how-to-get-into-y-combinator/ <comment> foti-panagio After applying myself and not getting in for the S19 batch, I decided to do some research.

What if I just reached out to the founders that actually did get in, and just straight up ask them the nitty gritty questions of how they did it?

So I proceeded to do exactly that.

3 months later, countless hours of interviews, transcribing, and editing, I'm finally done.

[https://www.growthmentor.com/blog/post_series/y-combinator/](https://www.growthmentor.com/blog/post_series/y-combinator/)

There are 12 interviews live now but will be adding a few more over the next couple of weeks.

For anyone applying to this next batch, I wish you the best of luck.

Really hope this helps!

<comment><AUTHOR> Did you account for survivorship bias? Eg, did you also ask a bunch of folks who failed to get in what they did, and examine whether they did all the same things as the successful applicants but just got unlucky?

[https://wikipedia.org/wiki/Survivorship_bias](https://wikipedia.org/wiki/Survivorship_bias)

</comment></comment><comment><USER2> You know what would be 10x as useful as this AND account for survivorship bias? If you did this same format but instead only talking to founders who failed one or even multiple times before eventually getting in. Then they could compare and contrast what they did wrong originally and how they corrected it. That would be much more useful to me, and wouldn't stink of survivorship issues.

<comment><USER3> I would like to see a list of per-company YC outcomes vs. outcomes with traditional VCs. Is it worth "getting in?", or is it just a low paying job with long hours, with nobody winning, on average, except YC itself?

<comment><USER4> I don't know about being in YC vs raising capital directly. But getting into a program like YC makes it significantly easier to raise money.

</comment></comment></comment><comment><USER5> > How much time and effort did you put into the application?

Spent a whole week on it because the questions were really good and had to do a lot of thinking and research.

> Do you need traction to get into Y Combinator?

At its core, to get in YC you need an insight to build something that has the potential to be a $1B+ company. Having traction is great because it shows that this insight is grounded -- but this isn't required.

If you have no insight and no traction, then you need something else exceptional to convince them to invest in you rather than the idea.

> What are some tips for writing the written application?

Don't bullshit and get a founder from YC to review the application. Unlike most people, you don't need to "bullshit YC" to get in.. they actually _want_ to fund you as long as you can prove that your insight is grounded and made significant progress relative to where you were a few weeks earlier. Also, be concise because they're reading thousands of applications.. if as the CEO you can't be concise, it's kind of a red flag against you that you won't communicate properly to customers, employees and investors.

> Bonus tips on how to get into Y Combinator

Don't read too much into "How to get into YC" things. Be ruthlessly focussed on working on your product and talking to users. Better to fail fast and move on to a different product if users don't love it or you're not solving a major pain point.

<comment><USER6> I've applied before but, looking back, my idea likely wasn't a $1B idea. For those of us with ideas in the $10m-$100m's range: What is our best avenue? I think those of us that have business ideas in that range, you know, we still have something valuable to offer society, even if it doesn't get an investor a very big return.

</comment></comment><comment><USER7> The article doesn't mention how they account for survivorship bias. Does anyone know?

<comment> foti-panagio Who is "they"?

<comment><USER7> Authors of the article

</comment></comment></comment><comment><USER8> On a related note: [https://news.ycombinator.com/item?id=20919455](https://news.ycombinator.com/item?id=20919455)

</comment><comment><USER9> Are the YC applications ever made public?

I am not really paranoid about 5-10 partners reviewing my application. But i would not want to be permanently google-able

<comment> foti-panagio No, they are never made public.

</comment></comment><comment><USER10> Thanks for including Suiteness Foti, we are always happy to help other founders.

</comment><comment><USER11> Many of the founders prepared in the ur chat where YC alumni payback by helping new one to shape theirs startups: [https://openland.com/invite/wT6XDbT](https://openland.com/invite/wT6XDbT)</comment>


'World's Most Secure' Email Service Is Easily Hackable - <AUTHOR> https://motherboard.vice.com/en_us/article/worlds-most-secure-email-service-is-easily-hackable <comment><USER2> An extensive discussion of the details is here:

[https://news.ycombinator.com/item?id=14209874](https://news.ycombinator.com/item?id=14209874) (scotthelme.co.uk, 69 comments)

And here:

[https://news.ycombinator.com/item?id=14232872](https://news.ycombinator.com/item?id=14232872) (vice.com, 10 comments)

NOMX responded, and the discussion about that is here:

[https://news.ycombinator.com/item?id=14220171](https://news.ycombinator.com/item?id=14220171) (nomx.com, 26 comments)

Also submitted here, although with no discussion:

[https://news.ycombinator.com/item?id=14218905](https://news.ycombinator.com/item?id=14218905) (bbc.co.uk)

[https://news.ycombinator.com/item?id=14214549](https://news.ycombinator.com/item?id=14214549) (nomx.com)

[https://news.ycombinator.com/item?id=14214276](https://news.ycombinator.com/item?id=14214276) (arstechnica.com)

[https://news.ycombinator.com/item?id=14205379](https://news.ycombinator.com/item?id=14205379) (scotthelme.co.uk)</comment>


New version of jobs code - <AUTHOR> http://ycombinator.com/newsnews.html#12may11

<comment><USER2>
      Jobs no longer have points or submitters

<http://news.ycombinator.com/jobs>

This page still shows the submitter and points (though with the new system upvoting presumably doesn't make a difference - however it still works to store that story in my "saved" list).

<comment><AUTHOR> Oops, fixed, thanks.

</comment></comment><comment><USER3> PG: Any chance of ever opening jobs up to the rest of us? Maybe with a karma threshold?

My contention has always been that it would actually help YC companies as well, because the job section would get a lot more page views. YC companies could be highlighted and/or sorted to the top.

<comment><AUTHOR> I think it's ok for YC cos to derive at least that much unique benefit from HN. Also I'm hoping that once the jobs page doesn't suck, it will get more page views. The jobs code had suffered from such bit decay that a lot of YC cos stopped posting jobs on HN. I'm hoping this will fix that.

</comment></comment><comment><USER4> Dimming the job posting text is weird, since there are no comments. Actually, dimming the initial post in general is pretty weird. Is that just so the focus is on the comments?

<comment><AUTHOR> Good point. I do that for self posts as you say to focus on the comments. But for jobs I don't need to. I'll also make links work. I did some pretty aggressive code reuse when I first implemented jobs...

</comment></comment><comment><USER5> Does that mean Arc3.2 might show up soon?

Also, thanks for putting years on the dates of newsnews.html . You might've done it before, but I just saw it now.

<comment><AUTHOR> Not very directly alas. Maybe indirectly in the sense that it's a sign that I'm not so busy with YC that I have time to actually write code. But unfortunately those windows seem to be getting shorter.

<comment><USER6> Not that I would pick it up myself, but maybe it's a good time to put it on github and let this community run with it?

<comment><USER7> I believe it is on GitHub <https://github.com/nex3/arc>

<comment><USER8> That's not an official release, no. It has two major branches: one which gets only pg's official releases, and one which anyone can submit code to without restriction (it's called anarki because it's kinda like a wiki: <http://arclanguage.org/item?id=803>)

Several of us have started curated repositories, but the community has not coalesced around one of them: <https://sites.google.com/site/arclanguagewiki/home>. Like any lisp arc is easy to, and liable to, fragment.

</comment></comment></comment></comment></comment><comment><USER9> How about making the job titles green (or whatever color) to make them stand out more clearly on the fornt page?

</comment><comment><USER10> why not just put a tag in place of the up arrow that says (Job) or (Job Ad). That's more intuitive to me (I'm new to HN).</comment>


Show HN: Teaching Javascript to Write - <AUTHOR> http://zwass.github.io/Learn2Write/

<comment><USER2> You should follow up on this! A more detailed explanation of how you implemented it would be an interesting read.</comment>


Magic: the Gathering is Turing Complete - <AUTHOR> http://www.toothycat.net/~hologram/Turing/index.html

<comment><USER2> what, no MTG lovers here? this is totally awesome!</comment>