An empirical study on the impact of C++ lambdas and programmer experience - <AUTHOR> http://dl.acm.org/authorize?N03390 <comment><USER3> > After instructions, participants were given printouts of sample code they > could refer to while solving tasks. Group Lambda got code of a C++ program > using lambda expressions and group Iterator received code of the same > program written using iterators. They then had time to study the samples > before starting the tasks and could refer to these samples later.

These samples do not appear in the paper, so we don't know what they saw.

The "iterators" discussed are Java-/C#-style iterators, not C++ ones (as I expected reading the abstract).

In a C++ context I would have expected lambdas vs iterators to be something like:

        // lambda
        float retVal = 0;
        std::for_each(mb.cbegin(), mb.cend(), [&](item x) { retVal += item.price; });
        return retVal;

        // pure iterator
        float retVal = 0;
        for (auto it = mb.cbegin(); it != mb.cend(); ++it)
        {
            retVal += it->price;
        }

        return retVal;

... and the first would be better off as:

        return std::accumulate(mb.cbegin(), mb.cend(), 0f,
            [](float acc, item x) { return acc + x.price; });

I think the need to use ref-capture (since you only get a side-effecting `std::function` to play with in their sample) would be the thing most likely to throw people off – as it's something that should be avoided in most code, anyway ;)

<comment><USER4> Yeah - from what I can see, neither interface looks like idiomatic C++.

EDIT: Looks like you beat me to the punch on some of these ;)

Instead of:

      float getSum(marketBasket mb) {
        float retVal = 0;
        // Implement solution here
        // </comment></comment><comment>---
        marketBasket::iterator iter = mb.begin();
        while (iter.hasNext()) {
          retVal += iter.get().price;
          iter.next();
        }
        // </comment><comment>---
        return retVal;
      }

I'd rather see real SC++L compatible iterators (as hopefully taught) and saner naming:

      float getSum(marketBasket market) {
        float sum = 0;
        // Implement solution here
        // </comment><comment>---
        for (marketBasket::iterator item = market.begin(); item != market.end(); ++item) {
          sum += item->price;
        }
        // </comment><comment>---
        return sum;
      }

And instead of being pre-provided with a function <void(item)>, if I'm reading the pdf correctly:

      float getSum(marketBasket mb) {
        float retVal = 0;
        // Implement solution here
        // </comment><comment>---
        function <void(item)> func = [&](item theItem) {
          retVal += theItem.price;
        };
        mb.iterateOverItems(func);
        // </comment><comment>---
        return retVal;
      }

I'd rather see:

      float getSum(marketBasket market) {
        float sum = 0;
        // Implement solution here
        // </comment><comment>---
        market.for_each([&](item theItem) {
          sum += theItem.price;
        });
        // </comment><comment>---
        return sum;
      }

Or venturing into the far more functional style, where lambdas start to shine for me, personally:

      float getSum(std::vector<item> market) {
        // Implement solution here
        // </comment><comment>---
        return std::accumulate(market.begin(), market.end(), 0.0f, [&](float sum, item theItem) {
          return sum + theItem.price;
        });
        // </comment><comment>---
      }

It looks a bit better in C# where your selection of standard functions is a little less anemic and a little nicer to use:

      float GetSum(MarketBasket market) {
        // Implement solution here
        // </comment><comment>---
        return market.Sum(item => item.Price);
        // </comment><comment>---
      }

<comment><USER5> "Idiomatic" doesn't necessarily mean better. I think objectively it's hard to argue that "item != market.end()" is superior to "iter.hasNext()". The latter accurately reflects the programmer's intent, while the former specifies an unnecessarily specific (and poor) implementation of the intent. First of all, using something like "market.cend() != const_iter" instead is arguably better practice (imagine you unintentionally omit the "!"). But programmers shouldn't need to consider whether the iterator is const or not when they just want to know if the loop is done. Also, consider the case where the vector is being modified (items inserted or deleted) inside the loop. It might be problematic either way, but "item != market.end()" is particularly bad in that situation.

Shameless plug: [http://duneroadrunner.github.io/SaferCPlusPlus/#msevector](http://duneroadrunner.github.io/SaferCPlusPlus/#msevector)

<comment><USER6> > I think objectively it's hard to argue that "item != market.end()" is > superior to "iter.hasNext()"

Until you realize the purpose of the weird syntax in the former.

Namely: you can write algorithms where an iterator is a drop-in replacement for a simple loop through all items in an array via pointer arithmetic, if you write it to take a start and an end iterator as templates.

Plus said algorithm can take sub-ranges instead of requiring it to loop through all items.

I thought c++ iterators were very strange for many years until I understood this and other rationales.

<comment><USER5> Ah yes, that makes total sense. I suppose those that would like a nicer interface can just implement one on top. Like the proposed array_view<> and span<> interfaces.

</comment></comment></comment></comment><comment><USER7> Context always matters. I use lambdas sparingly in my applications, except for one _major_ area: user interfaces.

I can't begin to stress what a huge timesaver it is being able to bind a button's callback to a quick lambda instead of having to bind a callback to an std::function, add the function to the class header, and then put the actual button-click code somewhere else in the project in a separate function ... and then repeat that process for a large UI with hundreds of widgets.

It's not even the initial extra typing, it's having all the code right where it's most relevant instead of scattered around everywhere and having to name all of these callback functions.

<comment><USER8> Yeah I think this is the real win - the examples in the paper don't really cover any of the real reasons why someone would use functional programming. The places that I've used C++ lambdas a lot are callback-heavy code, i.e. things with a lot of asynchronous I/O, multi-threading, etc.

While I don't doubt the validity of the argument that it takes longer for a programmer to write correct lambda code in C++ (I have been using them since C++11 was released and still forget the capture list syntax sometime), it's not much more than an academic exercise to take some iterator-based code and replace it with higher-order function calls. It's unfortunate that all the tasks seem to be based around doing that though. I do think it is still reasonable to do this in C++11 once you know how - with -O1 turned on you can get basically the same code spit out using std::transform, std::accumulate, std::for_each, et al, as you would using a for loop.

It's also unfortunate to note that, at least in g++ and clang, there is still significant advantage to using lambdas over std::function and std::bind. Lambdas typically end up being faster in both compile-time and run-time, and end up generating less code. For these reasons I've found myself using them a lot more, especially anywhere I would have done some type of currying. This I do miss somewhat, but it's still leaps and bounds ahead of something I would have written in C++03.

<comment><USER7> > It's also unfortunate to note that, at least in g++ and clang, there is > still significant advantage to using lambdas over std::function and > std::bind.

I have to say, std::bind is just a travesty. It's so difficult to bind a member function pointer that takes multiple arguments to an std::function.

I wrote my own so that you can do this with just: function<void (int, int)> f = {&Class::func, &object};

Source is here: [http://hastebin.com/raw/kobudabasa](http://hastebin.com/raw/kobudabasa)

In doing so, it becomes clear there's basically two ways to implement this idea:

1\. you allocate heap space to perform type erasure. This results in a pointer indirection plus a virtual function call worth of added overhead. Along with tremendous costs to allocate and destroy the function objects.

2\. you store a big chunk of raw memory inside the function<> class, and cast it as necessary to a pointer. This is actually what I did prior to C++11 and lambdas. It was tricky because the size of member function pointers is undefined. Having a vtable makes them larger. So for that I made a complex dummy class to pull its sizeof info.

Option 2 is definitely a good bit faster (at least for constructing/copying/reassigning/destructing them), but you're really butting up against undefined behavior and abusing the language. And capturing lambdas would be even more challenging.

But even with that, yeah, you can't ever really beat concepts that are native to the language like lambdas and virtual functions themselves. Compilers can get really clever and inline things in a way that's exceedingly unlikely to ever occur with std::function, no matter how you implement it.

<comment><USER9> I've also written my own "version" of function but intentionally lightweight, for an embedded project: [https://github.com/ambrop72/aprinter/blob/master/aprinter/ba...](https://github.com/ambrop72/aprinter/blob/master/aprinter/base/Callback.h)

Callback<void(int, int)> f = APRINTER_CB_OBJFUNC(&ThisClass::function, this);

One magic thing is that the macro is just a value, it figures out the type itself.

There's zero memory allocation. The Callback class just contains a function pointer and a void pointer. So you can't bind argument values other than the object pointer, but I have no need for that.

</comment></comment></comment></comment><comment><USER10> This is ridiculous. C++ lambdas (and std::function) don't replace iterators except for the most fervent disciples of the Church of Haskell. They replace single-function interfaces in cases where you would have had to put together a custom struct that did exactly the same thing as a lambda with capture but in about 15 more lines.

<comment><USER11> To be fair, the most fervent disciples of the Church of Haskell would use Haskell I'd think :)

I only scanned the paper, but I get the impression the title was chosen specifically to grab attention. "An empirical study comparing the use of C++ lambdas versus C++ STL iterators and programmer experience" wouldn't get eyes on their presentation, and eventually, being posted to HN...well, it would, but they'll surely get more reads/downloads this way.

Clickbaiting for conference proceedings, who would have known.

<comment><USER12> Such a title wouldn't be right, either. Their poor iterators don't seem to act like real iterators.

</comment></comment></comment><comment><USER13> The paper seems to mainly compare iterators vs lambdas. This seems like a bit of a strawman; the best use of lambdas is beyond iterators.

For example, consider callback heavy asynchronous code. A promise library with lambdas is much easier to write and read than the equivalent state machine.

I would go as far to say any mechanism where function chaining is useful, such as the nice data to mark/SVG abstraction used in D3, and also in promise libraries, has advantages with lambdas. Not only do you avoid having to write extra classes or methods, but the code is more succinctly logically grouped together, requiring fewer indirections to get to the transformations occurring.

<comment><USER14> Basically anywhere where you would have used a callback in C code could probably benefit from a C++ lambda. It's easier to see what's going on, you don't litter your code with hundreds (or thousands) of tiny functions, and the compiler can easily inline everything. The fact that you can capture whatever you need makes it super easy to use inside a class if needed (eg; you need to access class members).

It seems really dumb to me to declare that lambdas are detrimental to novices when it's clear they have a great deal of utility outside of something like replacing iterators.

<comment><USER15> I'd much rather have a lot of smaller functions with single responsibilities, but then being middle management I worry about things I didn't when developing.

I need the code to be SOLID, I need the time to market to be as small as possible and I need to be able to replace any developer with any developer on a moments notice.

When students don't know lambdas you're costing me money by using them, because you made the training process longer.

<comment><USER16> I'm glad I don't work for you...

<comment><USER17> I think I understand why turnover is such an issue. The reluctance to invest in your people is a little baffling.

</comment></comment></comment></comment></comment><comment><USER18> I'm a professional and you can take the lambdas out of my cold, dead hands.

Also, their examples are removed from reality. I've never seen people use lambdas like that. Most of the use cases I've seen are callbacks that get triggered on certain events (i.e. "display notification when background loading thread completes") and predicates (i.e. find_if). I see neither in their examples.

<comment><USER19> Of course students had problems—-it's one more damn thing for them to learn about C++, likely from professors that don't know it very well either. But <algorithm> is way more useful these days, and boost::asio is a dream.

<comment><USER20> Unfortunately most teachers aren't like Kate Gregory, and I fully agree with her, they should stop teaching C -> C++.

Already in 1994 it was obvious to me that it leads to bad unsafe code and worse, the mentality to micro-benchmark each code line.

<comment><USER14> There's pitfalls to everything. I find that a lot of people that only learned C++ end up writing nice-looking safe code that's very well organized but has awful memory usage and dubious performance characteristics. It's not that they're bad programmers or made poor algorithmic choices. It's that they've been indoctrinated with the fear of "premature optimization". Moreover, they don't really know any better if they do have optimization opportunities.

On the flip-side, the C programmer who starts out learning C++ will often spit out some hideous abomination that uses no namespaces, consists of obscure function names, pointers everywhere, and tons of callbacks.

Thing is, sometimes performance really matters. A large part of the HN audience focuses only on web-oriented programming. But in scientific computing, finance, etc. being able to squeeze out a few more operations/CPU cycle can be incredibly important.

I think rather than being dogmatic about the issue, as programmers tend to do, it's important to introduce students to C but be very clear about why you might want to use some of its features vs. relying on the safer C++ variants.

<comment><USER21> Out of interest, I never learned C but went straight to C++. What in particular about C++ makes you believe that you'll write memory hogging programs?

<comment><USER14> Specifically, the STL has a lot of slow containers that people readily use. For example, a beginner might see a std::map<T> and think "wow, a handy hash table class!". First off, it's not a hash table (usually a RB tree). Second, the closest thing to a hash table in the STL (std::unordered_map<T>) is still pretty slow.

Then there's std::string. Super nice in 95% of cases but can cripple an application if you have millions of strings you need to deal with (TONS of dynamic memory allocation).

And then there's std::shared_ptr. Super convenient but potentially a huge impact if you have items with very short durations in hot loops. std::unique_ptr on the other hand has no added overhead. Sure, you can look these things up. But it's not really obvious.

C++ is an incredibly useful language. It's far from the safest, prettiest, etc. But when used properly it's a very powerful tool. But knowing C can help you to better understand when you're not getting something for free and when undefined behavior can rear its ugly head.

<comment><USER21> I see, interesting, thanks. I suppose the same problems arise attempting to use STL algorithms instead of using algorithms that are better suited to a specific container, eg. std::set::find instead of std::algorithm::find.

Being aware of what is happening and the best tools for the job I suppose! And knowing the STL inside out and its idiosyncrasies and foibles.

</comment></comment></comment></comment></comment></comment></comment><comment><USER22> Title of the research paper should be "C++ is not Haskell", but snark aside, I find C++11 lambdas useful to replace old-school callback code (of course only if callbacks make sense in a situation) because:

\- if local variables need to be captured, the code is much less noisy than using the old std::bind mess

\- non-capturing lambdas also work for C-style function pointers, and in this case the generated code is very efficient (no std::function object created under the hood)

If you're aware what happens under the hood (...that in most cases a std::function object will be created, which in turn might do a dynamic memory allocation to hold captured variables), lambdas are a useful syntactic sugar and one of the more useful additions in C++11 (IMHO).

<comment><USER23> I'm pretty sure that most uses of lambda don't involve creation of std::function (and thus dynamic allocation and virtual function calls).

As long as you maintain the distinct type of the lambda, any captures (by reference or by value) will just be fields in a stack object.

</comment></comment><comment><USER24> The only true conclusion of this study is that students find C++ a bit intimidating.

Which is not surprising at all, because C++ is a very complicated language !

It takes _years_ , even _decades_ before you can master this language - <USER2> then you probably won't be using all of its features.

Back in the day, it took me a long time before I could truly grasp the C strings and pointers in general.

Yes, I could write code with pointers and C strings (new char[length + 1] and delete[] str; were my buddies!), but sometimes I was programming with my eyes closed and fingers crossed, because the implications of sharing raw pointers were too complex, especially if threads were involved.

Same with these new features. They may 'look' more modern due to the updated syntax, but the underlying concepts that they are hiding still need to be well understood.

So not surprising that students struggle with getting it right the first time. The good news is that with a bit of experience this becomes easier, as with anything else..persistence is key.

<comment><USER21> Yes C++ is complicated and yes students struggle with programming. It takes years to understand how to put a decent program together (separation of data, logic and transport etc).

As for your guesswork with C-style strings, you should have been using std::string and using copy constructors to pass work into a thread (eg. who owns the data the thread is working on?). With modern things you can move the data into the thread instead of copying it.

I would recommend students working on their own personal projects as a good pasttime as it further helps anyone understand how to write a decent program and learn the language. Also, tell them to read Stroustrup's book.

<comment><USER24> I started programming back in the day when every programmer wrote his own String class :).

Standard library was, for one reason or another, unpopular back then. Or maybe because of the C Windows API and later MFC, which came with its own CString class...

<comment><USER21> Add to the confusion CString, BSTR and std::string and std::wstring. What could go wrong?

</comment></comment></comment></comment><comment><USER25> Some people feel comfortable expressing things in a more traditional way, in part, because you cannot change the habits built over the course of decades by just announcing a new standard.

After the standard including lambdas came out, compilers did not immediately comply to it, and it took some time for them to catch up. Then it took even more time for tutorials and books to catch up. And it will take time for the C++ community as a whole to catch up as well.

<comment><USER26> Compilers (at least clang, MSVC and GCC) released versions supporting lambdas well before the C++11 standard was finalized.

<comment><USER25> I see. The feature parity wasn't 100% I remember. There was also Boost Lambda since at least 2004

</comment></comment></comment><comment><USER27> Lambdas are an incredibly useful construct, and, once you master them, they do make a lot of programming tasks much easier.

However, C++ lambdas picked the most horrifically ugly syntax possible, and they switch between three subtly different semantics (copy, reference, move) depending on a single glyph. I feel bad for the people working on modern C++ - maintaining backwards compatibility is a huge constraint upon design space.

I'm not surprised that lambdas slow down people that aren't already experienced with them. Since I rarely program in C++, whenever I go back to it, I always have to spend a bit of time bashing my head against the horrific syntax.

<comment><USER28> C++14 improves upon lambda captures a lot. I'm also not aware of a move capture, only "by reference" (&) and "copy" (=). In C++14 you're allowed to put arbitrary assignments into the capture, e.g.

        [foo=std::move(bar)]() {}

<comment><USER29> I did that in the C++11 days by creating a bastard class template that would subvert the copy operator and turn it into a move and capture that by value.

It was ugly as heck and was removed as soon as I have c++14

</comment></comment></comment><comment><USER30> As a working C++ programmer for over a decade this conclusion is absolute insanity to me. People (myself included) are actually using the STL algorithms now because you no longer have to go through the pain of writing a functor. Every time I can avoid writing a for loop I'm a little happier (and my code is a lot more readable).

When lambdas first came about there was a lot of "meh, I could already write a functor just fine" but the ease of using them is just so much nicer and the readability of the code is so much greater. Just writing a plain for loop would often be less code than using an STL algorithm and a custom functor so there was very little incentive to use the highly tuned STL algorithms if it was just going to take more boilerplate. Now there is and we are finally seeing C++ programmers catching up to the insights that functional programmers had made a long time ago[1]

Others have said this but comparing lambdas to iterators is a very odd decision because they are completely unrelated things.

The conclusion should really be that anonymous functions aren't as intuitive as "regular" imperative code. The regular code walks you through what is going on in babysteps so even a new user can figure out what is going on. The way with lambdas requires a bit more knowledge but for working programmers who aren't learning C++ for the first time they are obviously a big boon. Sometimes you have to learn something slightly more complex to reap the benefits of it. Pointers are very hard for brand new programmers to wrap their heads around but nobody would argue that judicious use of them can be a real benefit (or essential, even) in some situations. This is like concluding that smart pointers are bad because they are less explicit about what is going on. You still need to learn C++ manual memory management but your code will clearly benefit (both in terms of verbosity and memory safety) by using smart pointers 95% of the time.

1\. CppCon 2016: Ben Deane "std::accumulate: Exploring an Algorithmic Empire" [https://www.youtube.com/watch?v=B6twozNPUoA](https://www.youtube.com/watch?v=B6twozNPUoA) (std::accumulate, fold essentially, has been in C++'s STL since the beginning and Stepanov probably had it in mind before C++ even existed but we are just now getting lectures like this and I think lambdas are to thank for this)

</comment><comment><USER31> It's important to note that the negative impact documented in this study is in development time and whether the task is completed. It makes no claims about impacts on maintainability that show up later in the development process. It also does not measure the longer term impact on development time if a team starts using lambdas and gains experience over time.

I say this not to dismiss the study, which appears to be fairly well done and to provide interesting results. I'm simply saying that its results are not inconsistent with lambdas providing a net, long-term benefit if introduced to a development team at work.

</comment><comment><USER32> Submitter's editorialized title mischaracterizes the OP

> All the tasks focused on iteration on a collection using a C++ vector > object.

That's comparing "functional style" collections to iteration.

It is readily apparent that C++ syntax is so troublesome that "functional collections" won't be a win for small iteration blocks.

We had the same debate for functional Java collection methods (although the Java 8 lambdas tilt it more closely in functional Java's favor)

The main use case for C++ lambdas is for declaring callbacks.

</comment><comment><USER33> As someone who writes a lot of asynchronous code in C++, lambdas have _changed my life_.

The paper seems to study the use of lambdas specifically as an alternative to iterators. I actually mostly still use iterators myself, rather than lambda- based alternatives, so I agree: they don't have a huge impact there.

But the headline is misleading. It should have had "when compared with iterators" added to the end.

</comment><comment><USER34> Recently I wrote a parser generator, which would take a rule structure and return a function that does the parsing. Lambdas were very useful here, and I do not know how I would've implemented this without them, at least in an efficient manner, because they let me do something like this:

        Parser ParserGenerator::compileLiteral(Rule& rule){

            const string literal = rule.value;

            Parser parser = [literal] (shared_ptr<State> state){
               //parse the literal...
               state.Advance(literal.size())
               return state;
           }

           return parser
        }

Solving this without lambdas would require a different encapsulation mechanism for the rule data, such as a class, which (IMHO) would make the code less idiomatic.

So lambdas are actually very useful!

<comment><USER35> Well, an alternative approach might to not to couple parsing and state manipulation :)

PEGTL does this. Approximately, you have a template parameter MyAction<> on the Parser<> template which in turn calls "MyAction<Rule>::apply (state)" when parsing of each rule is complete.

It's a fantastic library. I highly recommend giving it a whirl.

[0] [https://github.com/ColinH/PEGTL/blob/master/doc/Actions- and-...](https://github.com/ColinH/PEGTL/blob/master/doc/Actions-and- States.md)

</comment></comment><comment><USER36> Can you always replace lambdas with iterators? For example, to visit a graph you could implement it using function that takes two arguments; the graph to visit and a lambda holding the function (functor) to apply to each node.

It is fairly easy to implement and the compiler will inline the functor so there is no performance penalty. Any solution based on iterators that I can think of would be much more complicated and would probably not lead to as efficient code.

I'll admit that the "user interface" for iterators are much nicer than using functors. The former meshes well with c++:s for loop syntax while the syntax for lambda constructs is bad.

</comment><comment><USER37> I used to really like C++ ... back in 2000. That is before they added the kitchen sink into the language.

I prefer my computer languages to be like Chess - a few rules but efficient and expressive. Like C.

Why? Because everyone can read the code others on the team wrote, without being a language lawyer and knowing tons of esoteric features and magic.

That has implications for maintainability and team productivity, and the bottom line for a business.

Really, people, having basic coding style conventions instead of tons of language features wasn't so bad:

      int Foo_bar(struct Foo* this) {
         // even this is readable
      }

<comment><USER38> Very few people can read and understand C without being a language lawyer an knowing tons of esoteric magic. There are many things in C which look perfectly reasonable but which actually result in undefined behavior, and you cannot reason about what a program will do in the presence of undefined behavior.

<comment><USER37> But there is a difference between using C in crazy ways, and using 20 features of a language in ways that make them interact.

The more features a language has, the more I have to know just to read someone's code or be productive in a company - and the more chance someone doesn't know about potential harmful interactions and side effects.

<comment><USER39> _> there is a difference between using C in crazy ways_

As per my sibling, write me something as straightforward as a C++ RAII-using dtor in C without "using C in crazy ways". I will not hold my breath. The cost of a very minimal subset of C++ is _literally zero_ , and yet significantly improves the likelihood of your code actually working. You're picking social baggage in either case: either understanding the subset of C++ that your team is using or expecting all of your developers to be perfect where C++ (and other languages--shouts, Rust!) just do it for you, correctly.

Technology is socially interesting in that incompleteness and inexpressivity is so often misread as "elegance" or "minimalism". That a language is "simple" is not a feature when it offloads all of the danger onto the (almost invariably failing to consider critical information at the worst possible time, and I include myself at the forefront of that characterization!) developer. This is why we have tools that compensate for the most common, and most destructive, of our mistakes.

(This post should not be construed as any particular endorsement of C++. C++ is a gong show when used improperly. But at least it's possible for a mere mortal to use it properly.)

<comment><USER40> The reason I dislike C++ (since about the 2000 as well) is that while it is possible to shackle yourself to only using C++ RAII etc, the vast majority of code in the wild (and in libraries, etc) does not. It does 90%, but that doesn't get you 90% of the benefit (maybe 50%, maybe 0%, depending on your point of view).

You can do essentially all the "C in crazy ways" in C++ as well, and people do. In my opinion and experience, it isn't what the language provides, it is how it is used in practice - and again from my experience (YMMV), C is used sanely and C++ is not.

<comment><USER39> I think the profusion of use-after-free bugs and memory leaks in C code running all over the place should put the lie to this. And, further, modern C++ allows you to firewall off the damage of bad C++ and most C, when you are forced to interact with it, via unique_ptr and your own enforced RAII. (And the idea that using this is so pejoratively "shackling" is bonkers to me; being "shackled" to the use of railings on walkways over a pit of fulminating acid is just _the worst_.)

The idea that people use C "sanely" more often than C++ (or, you know, something actually good--further shouts, Rust!) doesn't pass the smell test. Are you checking the retval of every sprintf? Are you writing goto drops in every method where there's allocated memory, diligently checking every error code, and properly bailing out, every time? If so, you're that one percent. But you're probably not. And that's not a slight--I'm not, either. That's why I am proud to count myself as a member of a tool-using species, because we build (and have built) better tools to compensate for our flaws.

<comment><USER37> So that's easy:

      #define NEW(t, args...) ((t*)malloc(sizeof(t)) && t ## _construct(args))

      #define DELETE(t) (t ## _destruct() && !free(t) && (t = NULL))

<comment><USER39> This isn't sufficient unless you consciously error-check and goto-trap _every single failure point in your code_. Which you might do. But you'd be the literal one percent. If not the literal one permille.

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER41> There's a guy at work whose position is unclear to most. It's just that random guy.

Typically, on monday mornings and friday evenings, he's very loud and looking busy. This is an age-old trick to superficially keep your job.

Ever so often one would hear his odd sounding voice pierce through the office talking about some idiosyncratic evidence while looking proud of himself.

Truly, if this guy was a programmer (which I doubt), he would be using lambdas. See, lambdas might have a use after all...

</comment><comment><USER42> I have used lambdas heavily in the past and then stopped. Getting away from the rabbit hole that are lambdas + SFINAE + variadics increases productivity immensely.

</comment><comment><USER43> It seems that the most important conclusion of the article is that using lambdas is more error prone than using iterators. What begs the question: how many compiler errors were caused by the actual lambadas, and how many were caused by the declaration of a `std::function` variable, as induced by the authors (that besides unnecessary, is somewhat of a bad style)?

</comment><comment><USER44> Paper says that "those in lambda group received no benefits in regard to [...] compiler errors".

Really, would anyone expect lambdas to improve compiler errors? Also, isn't that a problem of the compiler, and not of the lambda idiom in C++ or C++ language itself?

I mean, idk about clang, but at least compiler errors from msvc and gcc have always been hard to understand, with or without lambdas.

</comment><comment><USER45> Is the paper available in public domain? If not, I won't regret much. Looks like it's badly written and filled with un-idiomatic C++ code.

</comment><comment><USER46> How and who allowed them to publish such a ridiculous paper !!?? There is so many un-idiomatic C++ code... And does the topic even fit to be published as part of ACM ??

</comment><comment><USER47> I'm so relieved the consensus is negative here.</comment>


Tox: A simple, distributed, free, secure Skype replacement. Now alpha with A/V - <AUTHOR> Tox is now usable and has reached alpha (in other words, it is mostly working, but lacking some features, bugs might be apparent).
uTox is a lightweight (minimal dependencies) Tox client for Windows, Linux and (experimentally) Android. It supports text chat, file transfers, audio and video calling, desktop sharing (both as video and as screenshots). It also supports text-only group chats (with audio/video being worked on).
For more info about Tox and uTox, see the project links below.
Windows updater/downloader:
https://jenkins.libtoxcore.so/job/utox_update_win32/lastSuccessfulBuild/artifact/utox-updater.zip
Linux nightlies:
64-bit:
https://jenkins.libtoxcore.so/job/uTox_linux_amd64/lastSuccessfulBuild/artifact/utox/utox_linux_amd64.tar.xz
32-bit:
https://jenkins.libtoxcore.so/job/uTox_linux_i686/lastSuccessfulBuild/artifact/utox/utox_linux_i686.tar.xz
If you use an operating system other than windows or linux (OSX or android) or want to try other Tox clients, see this page:
https://wiki.tox.im/Binaries
Project links:
Official Tox website:
https://tox.im
uTox Github:
https://github.com/notsecure/uTox
toxcore Github:
https://github.com/irungentoo/toxcore
Other links:
qTox Github:
https://github.com/tux3/qTox
Antox Github:
https://github.com/Astonex/Antox
Note about adding friends in Tox: in the settings area of uTox you can find your Tox ID, and you give that out to your friends so that they can add you. To solve the inconvenience of sharing long IDs, Tox also supports "DNS names", for example "firstname.lastname@example.com". You can register your own @toxme.se name on toxme.se
Tox is alpha software, bugs are expected.
Feel free to post any questions or feedback or visit us on IRC: #tox on freenode. <comment><USER2> I don't post often on HN, but today couldn't resist. Just tested Utox on Windows as well as Toxy, also on Windows. Both programs are totally inaccessible for people using a screenreader and I'm quite sure as well for people using things like speech recognition.

Utox seems to be C++ and a GUI framework I didn't look into. Toxy is .NET+WPF... two different stacks, but two inaccessible programs. I'm quite sure the developers didn't write inaccessible software deliberately, but this makes me wonder if we need either:

1\. Inform developers better about accessibility 2\. Fix tooling: warn/error if you don't label your elements etc 3\. All of the above...

To give this post some more context, earlier this week I looked at Stellar... their web client is inaccessible. Earlier this week Wunderlist released a version 3... iOS app is nearly inaccessible. Earlier this week I finally wanted to give Foursquare's new Swarm app a shot... inaccessible. Do you see the pattern? I'm sorry for ranting about this, but imagine some random app update did stop the app from working and only displayed a black screen, you would be annoyed at least.

<comment><USER3> Seems like these would be useful suggestions to add to the respective github pages of those projects. Also, they are open-source, so there's an opportunity there if you have expertise in making UI's accessible.

</comment></comment><comment><USER4> In the spirit of supporting as many individuals as possible, Tox websites are now accessible as a hidden service via Tor.

The hidden service mirror has been stripped of Piwik tracking, and forms of Javascript, and soon we'll label outbound links.

i2p support will also follow soon.

Tox main site: [http://kdzzxucnh4fyovxg.onion/](http://kdzzxucnh4fyovxg.onion/)

Tox developer documentation: [http://kdzzxucnh4fyovxg.onion/docs/](http://kdzzxucnh4fyovxg.onion/docs/)

Tox wiki: [http://kdzzxucnh4fyovxg.onion/wiki](http://kdzzxucnh4fyovxg.onion/wiki)

</comment><comment><USER5> What about its design makes it secure? Do you guys have a design document or a description of how you've implemented security? Have any security experts audited the code?

<comment><USER6> This is a good question. What makes it secure ? "encryption" is not enough. Do you have central servers or is it protocol using P2P ? how do you connect one client to another ? What kind of encryption ? How are the key generated, can we change them etc...

<comment><USER7> The whole protocol is decentralized and peer to peer. Each person in the network has a public and private key. The NaCl library is used to do all of the encryption.

<comment><USER6> Cool. Is this direct connection from peer to peer or does the communication bounce from one node to another as a TOR communication would do ? (I'm guessing direct for obvious latency reasons when using audio / video)

<comment><AUTHOR> Direct connection when possible.

Connection routed over one TCP node when direct connections are impossible due to NAT issues.

<comment><USER8> Does only the one-time signalling handshake go to a TCP node (NAT hole punching) or does all traffic? Are these TCP nodes similar to Skype "super- peers" \- how are they selected?

Virtually all consumers are behind NAT devices.

<comment><AUTHOR> The majority of NATs can be hole punched.

If you can't hole punch then you will connect to your friend through a couple TCP nodes. They act like relays.

TCP nodes are pretty much randomly selected by peers and anyone can host them.

Everything is encrypted and TCP nodes are regarded as being possibly hostile so there should not be any security issues.

</comment></comment></comment></comment></comment></comment></comment><comment><USER9> Do you sync messages across various clients? So that I can start chatting on one and move to second or third client.

<comment><USER10> Not yet. This is a planned feature but the implementation has not been decided yet because this feature is not exactly compatible with how Tox works and it could cause a lot security issues.

</comment></comment><comment><USER11> can someone please explain in easy to understand how alice and bob find each other with temporary public keys in the DHT? I read this ([https://github.com/irungentoo/toxcore/blob/master/docs/Preve...](https://github.com/irungentoo/toxcore/blob/master/docs/Prevent_Tracking.txt)) but I still can't picture it (the wording isn't the greatest either). Thanks!!

</comment><comment><USER12> NB: the tox project website is unusable w/o JS enabled. Please fix that.

[https://tox.im/](https://tox.im/)

While we're at it, the rest of the suggestions may be useful: [http://www.reddit.com/r/dredmorbius/comments/27d5xr/please_f...](http://www.reddit.com/r/dredmorbius/comments/27d5xr/please_forward_to_marketing_how_to_present_your/)

From the FAQ, this I like:

"The goal of this project is to create a configuration-free P2P Skype replacement. _Configuration-free means that the user will simply have to open the program and without any account configuration will be capable of adding people to his or her 's friends list and start conversing with them._ There are many so-called Skype replacements and all of them are either hard to configure for the normal user or suffer from being way too centralized."

A lot.

(Emphasis added).

<comment><USER10> The website should be completely functional with JS disabled (and it is for me), what issues do you get?

Note: I'm not in charge of the tox.im website, if it were up to me there would be no javascript at all.

<comment><USER12> Chromium w/ ScriptSafe installed: no text until I allow the primary domain's JS:

[http://imgur.com/6xOfCr0](http://imgur.com/6xOfCr0)

[http://imgur.com/E8WK98R](http://imgur.com/E8WK98R)

<comment><USER13> You should probably submit a bug report to ScriptSafe.

</comment></comment></comment></comment><comment><USER14> So, This is pretty cool, however, one thing that I noticed: Addresses are per device. Skype lets you have one name and messages and calls come to all your devices, but as far as I see, Tox is one address per device.

<comment><USER15> I remember reading discussion how to address this problem. I can't for the life of me find it, though.

<comment><USER16> This is where the original (fairly old) idea is on the wiki: [https://wiki.tox.im/Multiple_Devices](https://wiki.tox.im/Multiple_Devices)

Here is a breakdown of the different ways they are considering on how to implement it: [https://github.com/Quoturnix/ProjectTox- Core/wiki/Multiple-d...](https://github.com/Quoturnix/ProjectTox- Core/wiki/Multiple-devices)

</comment></comment></comment><comment><USER17> Can you compare this to Jabber+Jingle?

<comment><AUTHOR> Tox is distributed meaning it doesn't rely on any central servers.

<comment><USER17> This would be good to note in the post, since right now it's easy to decide not to click anything because there are so many links and the salient feature is never mentioned prior to visiting them!

<comment><AUTHOR> Fixed.

Thank you.

</comment></comment></comment></comment><comment><USER18> So, what is the difference between utox_linux_amd64.tar.xz and Venom from [https://repo.tox.im/rpm/](https://repo.tox.im/rpm/) ?

</comment><comment><USER19> Is toxcore the name of the protocol? Would it be somewhat compatible with XMPP or something like that? I like that it's between FB messenger, gchat/hangouts, viber, what's app, Skype and hosted xmpp.

I think it will have a chicken and an egg problem unless there's some kind of tool that let's you talk with other older apps and protocols like gchat/hangouts, or maybe this is planned.

<comment><USER20> It will most likely not be compatible with anything but Tox itself unless someone makes a bot to bridge between the two. For example there is currently a bot in the groupchat (Syncbot) which is a bridge between Tox and IRC.

Bot example here: [https://github.com/aitjcize/tox-irc- sync](https://github.com/aitjcize/tox-irc-sync) More info on the protocol here: [https://github.com/irungentoo/toxcore/blob/master/docs/updat...](https://github.com/irungentoo/toxcore/blob/master/docs/updates/DHT.md)

</comment></comment><comment><USER21> This is great! Is there an Android version, and if so, are you OK with me writing a telepresence bot control API for it? (It's just a couple of hooks to a control app, if you're not releaseing source, I can just give you them).

<comment><USER22> Antox, the android client: [https://github.com/Astonex/Antox](https://github.com/Astonex/Antox)

Please do! It's all free and open source.

</comment></comment><comment><USER23> How does it differ from Retroshare? [http://retroshare.sourceforge.net/](http://retroshare.sourceforge.net/)

</comment><comment><USER24> Can you explain why tox is written in C over languages?

<comment><USER25> Knowing the typical Arch/Gentoo tiling WM 8px console font anime wallpaper mindset on /g/, "bloat".

<comment><USER24> I just did an analysis of the people involved in this project. Tox even more than cryptocat, is a very dangerous product to use. Even Tor has flaws while having many very capable cryptographers behind it. Tox appears to be swiss cheese both in code and protocol.

Rather than ricers with -Ofast kernels and overclocked CPUs it would be nice if a mature team focused on security and correctness first.

<comment><USER26> What was your "analysis" and how is it "very dangerous"?

<comment><USER24> This is a start, [http://www.tox-chat.com/](http://www.tox-chat.com/)

Like cryptocat, tox claims things that are not proven to be true by developers that aren't qualified to be writing or designing the protocols for a secure encrypted chat.

Having the intent to do something isn't the same thing as actually being _able_ to do it. People will use tox and get p3wnd with very dire consequences.

</comment></comment></comment></comment></comment><comment><USER27> i've been keeping an eye on this project for a while, it looks really promising. I'm spreading the word about it where i can.

<comment><USER28> How is it superior to existing IM protocols (eg: XMPP)?

The article comapres it to skype, which is popular, but, techonologically, one of the worst protocols around.

<comment><AUTHOR> Tox is distributed meaning there are no central servers.

Also, encryption is mandatory.

</comment></comment></comment><comment><USER29> Any chance of an iOS client any time soon?

<comment><USER10> Not any time soon, as iOS isn't very FLOSS friendly (in fact, the GPL is not compatible with the Apple app store). There have been talks of making a licensing exception, but the iOS client with the most progress ([https://github.com/Jman012/Toxicity](https://github.com/Jman012/Toxicity)) isn't functional at the moment.

<comment><USER29> Oh, that's a shame. Hopefully in the future there will be an iOS client.

<comment><USER30> Ask Apple to change their policy to allow copyleft software.

<comment><USER31> It has nothing to do with Apple's policy. The GPL is what's getting in the way: it says you can't impose restrictions on the redistribution of a GPLed application, and the App Store doesn't have any means to even _permit_ redistribution of apps once they're installed.

<comment><USER32> Seems like the App Store's problem.

</comment></comment></comment></comment></comment></comment><comment><USER33> Are group chats also encrypted? (The problem with jabber right now)

<comment><USER34> Yes, everything is encrypted from what I can tell.

</comment></comment><comment><USER35> why is it distributed in binary format?

<comment><USER29> they have links to their git hub repos, so it's also distributed in source format. Unless I don't understand what you're saying.

</comment></comment><comment><USER36> For those that don't already know, this project comes from 4chan's technology board. While there's a lot of inane trash, there are also some real gems if you're patient enough. I find lots of really cool stuff there that doesn't seem to be anywhere else.

More technically-capable people are always welcome to help drown out the inanity. :)

[http://boards.4chan.org/g/catalog](http://boards.4chan.org/g/catalog)

<comment><USER37> Interesting development: [http://boards.4chan.org/g/thread/43340418/its- official-bitto...](http://boards.4chan.org/g/thread/43340418/its-official- bittorrent-bleep-is-a-tox-clone-done)

<comment><USER36> Ignore all bait threads. Sage all bait threads. Report all bait threads. Hide all bait threads.

Don't take the troll bait. ;)

<comment><USER38> those "trolls" have a very sane point about having to be an idiot to trust bittorrent, the company.

<comment><USER39> Yes they sure do.

I was referring to the OP's "deprecated" meme.

</comment></comment></comment></comment></comment><comment><USER40> Posts without URLs are penalized. You might want to repost this using the most appropriate URL, then add your text as a comment to the post. If you like, email us at firstname.lastname@example.com with a link to the new post and we'll look it over for you.

Edit: this one seems to be doing fine.

<comment><USER41> Reading HN full time as a job must be extremely enjoyable. :)

<comment><USER40> It's like being paid to eat cheesecake.

<comment><USER42> Livin the dream, Dang

</comment></comment></comment></comment><comment><USER43> I guess you've settled on a name, pretty completely, but tox evokes all sorts of bad feelings like "Toxin", "Detox" \- generally feelings associated with the idea of poison or of poisoning yourself. From a marketing perspective this might not be the least sinister name you could have chosen. I realize this comes out of 4chan and we make a point of not giving a shit about marketing but...

<comment><USER44> I disagree, it sounds like "talks" to me.

Pretty cool name actually.

<comment><USER45> Whether "tox" sounds like "talks" will depend on whether or not your dialect exhibits the cot/caught merger. To those of us without, it sounds very different!

</comment></comment></comment><comment> throwaway-27677 This project has largely disappointed me in many ways. I know HN doesn't care much about software licensing and that kind of stuff, but there are many legal issues behind the project that remain unsolved and have remained unsolved for majority of the project's lifetime.

1\. The people behind Tox don't seem to be the copyright holders of their logo as admitted by one of the main developers[1]. The logo is the one also used on their website.

2\. Tox project is now attempting to (falsely) claim to be the copyright holders of the logo.[2] Wikimedia Commons deleted the project logo for legal concerns, and to date it remains deleted.[3] There is no concrete proof for Tox's copyright claims on the logos, while there's pretty concrete proof that the project indeed does not hold the copyright on the logos. For those unaware of how our legal system works, "works without license" are considered copyrighted work of the author (e.g. anonymous user on linked /gd/ board).

3\. Creative Commons licenses are also incompatible with their choice of software licensing, GPLv3+,[4] which means they cannot legally redistribute current logos under the current licenses with Tox software even if they were copyright holders to those logos.[5] As far as I know, the logos are already being redistributed with the software.

4\. The documentation also cannot be legally redistributed with the software, and in theory nobody outside the project has practical freedoms to modify the documentation.[6] "I'm le troll! :-)" was most likely added by the developers.

5\. Because of the above mentioned issues, Tox cannot be accepted to Debian GNU/Linux repositories because of DSFG guidelines.

6\. The above mentioned issues also create false advertising; "Tox is both free for you to use, and free for you to change. You are completely free to both use and modify Tox."[7]

7\. A developer quit the project because of other serious issues in the project.[8][9] The developer criticized the design of DHT (distributed hash table) used to find users, which leaked a lot of data about users. There's a large reddit thread about these DHT issues somewhere too, but I seem to be unable to find it myself right now. Fortunately, the leak was patched a long time ago. Unfortunately, the patch was a large hack which the Tox developers solved by reinventing the wheel and reimplementing Tor onion routing.

8\. I haven't verified this (so don't count on me), but the Tox core (or core + clients?) is now ~100k lines of code. It's not entirely lightweight per se, which was one of the initial goals as far as I remember.

9\. Another minor thing that upset me was that during Tox's conference talk (forgot which conference, but it was related to YouBrokeTheInternet), the speaker forgot to introduce himself and what he was doing. This probably led to some confusion.

10\. Possibly controversial too, but the first radio talk show Tox was introduced in was... could I say, maybe slightly cringeworthy. Or something. See it for yourself.[10]

Sorry if I went a little bit too political, knowing the rules. I wanted to point out these issues to let you know how everyone involved in the project can be a help.

[1]: [https://rbt.asia/g/thread/40445107#p40449131](https://rbt.asia/g/thread/40445107#p40449131) \- you can scroll down and read the replies too [2]: [https://commons.wikimedia.org/wiki/Commons:Deletion_requests...](https://commons.wikimedia.org/wiki/Commons:Deletion_requests/File:Tox_logo.svg) [3]: [https://commons.wikimedia.org/wiki/Commons:Undeletion_reques...](https://commons.wikimedia.org/wiki/Commons:Undeletion_requests/Archive/2014-03#File:Tox_logo.svg) [4]: [https://github.com/irungentoo/toxcore/blob/master/COPYING](https://github.com/irungentoo/toxcore/blob/master/COPYING) [5]: [https://www.gnu.org/licenses/license- list.html#ccbysa](https://www.gnu.org/licenses/license-list.html#ccbysa) [6]: [https://github.com/Tox/Docs/issues/7](https://github.com/Tox/Docs/issues/7) [7]: [https://tox.im/](https://tox.im/) [8]: [http://www.tox- chat.com/2013/08/tox-developer-fed-up-quits.h...](http://www.tox- chat.com/2013/08/tox-developer-fed-up-quits.html) [9]: [https://github.com/irungentoo/toxcore/issues/493](https://github.com/irungentoo/toxcore/issues/493) [10]: [https://www.youtube.com/watch?v=IdR3SVcBbq0](https://www.youtube.com/watch?v=IdR3SVcBbq0)

Disclaimer: I'm _not_ the author of any of the links above. It's what I have gathered from numerous discussion threads Tox has had on 4chan.

<comment><USER46> First, I suspect this is a concern troll named WubTheCaptain ([http://wubthecaptain.eu/](http://wubthecaptain.eu/)), or a copycat of the concern trolling he originally did, that has hung around the tox threads because he craves attention and replies. But I'll reply to some of these even though I'm not a tox dev.

1\. The logo was made, over many threads, by members of 4chan's /gd/ board for Project Tox to Do Whatever The Fuck You Want(tm)

7\. A developer quit the project because she was harassed into quitting by another notorious troll, SaveTheInternet (the creator of an australian imageboard 4chon) and friends in the 4chon IRC. Basically, the arranagement at the time seemed to be quit and I take your dox down.

As you can see, we have many problems with trolls, they're quite interesting creatures to harass a FOSS project like this for months on end but I suppose they redeem themselves in the entertainment value of how they bend over backwards for replies.

<comment><USER47> > 7\. A developer quit the project because she was harassed into quitting by > another notorious troll, SaveTheInternet (the creator of an australian > imageboard 4chon) and friends in the 4chon IRC. Basically, the arranagement > at the time seemed to be quit and I take your dox down.

Although there was doxing, the issues slvr highlighted were entirely valid. IIRC, slvr had raised these in a private mailing list and they were then leaked to the public, at which point doxing occurred.

<comment><USER46> The concerns were public in IRC, github discussions and on the wiki, with a proposal to fix it: [https://wiki.tox.im/Proposal:Slvr_Protocol_Rewrite](https://wiki.tox.im/Proposal:Slvr_Protocol_Rewrite)

I did not imply that the issue raised was not valid, only that the pressure to quit was with troll(s) wielding dox and wub is being disingenuous like always with his concern trolling.

<comment><USER47> Yeah, the proposed rewrite was public. A lot of slvr's more vocal criticism wasn't, though -- some private emails were leaked. But yeah, it was the doxing that made him quit. And that sucks.

</comment></comment></comment></comment></comment><comment><USER48> So why this when there's Hangouts?

<comment><USER49> Cause it binds you to a particular company, protocol, etc. This is open source, and does not create a single point of monitoring.

</comment></comment><comment><USER50> What makes the main developer, irungentoo, qualified to write the Tox core?

<comment><USER24> Starting a new, blue water distributed encryption system in a non-safe language is _odd_ at this point. The protocol is being _noodled_ through and the code is in C.

This is the coding style

[https://github.com/irungentoo/toxcore/commit/84c28337d248bad...](https://github.com/irungentoo/toxcore/commit/84c28337d248bad2319b5c001108b198dbd6bc5c)

this is openssl all over again

[https://github.com/irungentoo/toxcore/commit/1d6c3934736c369...](https://github.com/irungentoo/toxcore/commit/1d6c3934736c3694a7c9f694d818252e4159cde3)

<comment><USER51> From a short look, I tend to agree with you.

> memcpy(packet + 1, &con->ping_request_id, sizeof(uint64_t));

Copying multi-byte values into a network packet is a typical error made by novice developers - this will bite you hard as soon as somebody compiles the code on a Big Endian machine. Even if you might get away with this on opaque elements like a ping ID, the general approach should not be followed.

<comment><AUTHOR> endianess doesn't matter when you all you do with it is store it and check if it's equal to another.

In all cases where it does matter, the values are converted.

Tox has been confirmed working on big endian machines by many people.

</comment></comment></comment></comment><comment><USER52> Does Tox have plans to offer telephone numbers so that POTS subscribers can call Tox users?

If not, I don't see how it can be a replacement for Skype.

<comment><USER53> PSTN connectivity requires centralization

</comment></comment><comment><USER54> Warning: shameless plug. Sococo has a free replacement for Skype, including doc sharing, chat etc. Been around for years now.

<comment><USER55> Sococo doesn't seem to be open source

<comment><USER54> Free though. And lots of features.</comment></comment></comment>


Startup School videos on Omnisio, synchronized with slides and questions - <AUTHOR> http://omnisio.com/startupschool08

<comment><USER2> Wow. Never thought I would be endorsing another video/slideshow product this late in the game but Omnisio truly is head and shoulders above anything else. Just goes to show that if you can isolate a large subset of customers that are not being served very well even in a very crowded market (e.g. videos of presentations), you can do really well. Now show me a way of doing non presentation videos much better than youtube (yes, I did notice the mid-video user comments, good but not ground breaking!) and I'll be floored :)

Not to beat up justin.tv since they aren't really made for this kind of video but the contrast between the same video on justin.tv (or youtube) and on omnisio is just huge. Great work guys!

Edit: O.K. just noticed the subtitles that so subtly pop up at the right time. This keeps getting better..

</comment><comment><USER3> Omnisio is a damn good product. [EDIT: How long did it take to develop, if anyone knows?]

<comment><USER4> Thanks!

We started around end of October last year.

<comment><USER5> needs some more work :) as the videos seem to stop at mid points. nice though

<comment><USER4> It's actually a scaling issue - our server is seeing an order of magnitude more traffic than even our launch spike. We are working on a solution right now :)

</comment></comment></comment></comment><comment><USER6> While watching videos on Omnisio, I found the pop-up comments to be annoying. Maybe the comments should be off by default or let people vote up/down the comments so that you can remove the negative comments

</comment><comment><USER7> Looks great!

However for me, the videos stuck at some point -- Mike Arrington's at arount -17 min, and PG's also after about 5 minutes.

Even if I try to skip over this point, it just goeas back to "..I got my dog a few years ago <stop>".

Screen shot:

<http://screencast.com/t/lraJDenM>

I'm using Firefox 220.127.116.11 on Vista, Flash WIN 9,0,115,0

<comment><USER7> Update: I just watched the whole PG presentation, and it did not get stuck.

Also: Your UI rocks!

</comment></comment><comment><USER8> I'll echo the praise here, Omnisio is fantastically well designed. The picture quality, UI eyecandy, and overall presentation are stunning.

It's raised the bar for me. I'm drawn to hold myself to a standards somewhere near it. Thank you.

</comment><comment><USER9> It's not letting me finish talks. For example, right now Peter Norvig is halting at -15:20 and PG's talk is halting at -17:46. If I reload, the halting still happens, but at a different time. I've tried it on Firefox and IE on WinXP. Both apparently have version 9,0,124,0 of Flash.

Also, some of Norvig's slides aren't showing up.

</comment><comment><AUTHOR> (The rest are being uploaded as we speak)

<comment><USER10> What about for people without Flash, where's the download link?

</comment></comment><comment><USER11> Plus one for the comments about Omnisio. Justin.tv just wasn't cutting it. Especially during the talk with the Sequoia guy who did the whole "I don't even have to read this slide" thing.

</comment><comment><USER12> Yes I digg it, yet I am very tempted to add off color comments and act juvenile. I bring this up because I wonder if you guys are working on a system to scrape these types of comments?

<comment><USER4> We are working on a feature that will let you whitelist a set of people who are able to add comments. The author can also choose to disable commenting completely.

<comment><USER12> Yeah sounds cool ... just allow all my followers on Twitter to make comments for instance! Social YouTubing...

</comment></comment></comment><comment><USER13> The videos don't seem to work when I click play on several browsers/boxes. Are they still being uploaded or something?

<comment><USER4> Sorry we had to bump up the number of php-fastcgi processes to handle the large number of simultaneous users that suddenly hit the site :)

</comment></comment><comment><USER14> This could be great, but the video and sound quality is not very satisfying so far (video is jerky, sound distorted).

</comment><comment><USER15> Wow. Next best thing to being there.

</comment><comment><USER16> Yeah we are still uploading the videos. Should be finished later tonight though!

</comment><comment><USER17> Your site is one of a few that I've added to my bookmarks on the first visit.

</comment><comment><USER18> A great service, for sure. Thank you for your work on this.

</comment><comment><USER19> You guys are pimp. Love the video thumbnail for pg :)!

</comment><comment><USER20> Awesome. Thanks for providing this to everyone.

</comment><comment><USER21> 2 thumbs up on the player ^_^

</comment><comment><USER22> Wow!

</comment><comment><USER23> Apparently my Flash 9 is not 9 enough. Flash sucks.

<comment><USER24> I don't know about that. I would happily install flash once and be able to freely use something awesome like omnisio.

I would say that over-use of flash sucks and "click to skip preview" stuff is annoying.</comment></comment>


Gluon – A static, type-inferred and embeddable language written in Rust - <AUTHOR> https://github.com/gluon-lang/gluon <comment><USER2> Looks really interesting. The readme actually got me started with lots of good examples.

Side note though: I won't ever use a symbols-instead-of-words language unless I have to.

        let { (*>), (<*), wrap } = import! std.applicative

This is not my idea of good language syntax. I like jr developers, non-X language developers, hardware guys, and even graphic designers to be able to understand my code.

Consider simple string concatenation. This is what it looks like in Objective-C:

        NSString *one = @"Hello";
        NSString *two = @"World";
        NSString *three = [[one stringByAppendingString:" "] stringByAppendingString:two]

Total fail for something so simple.

<comment><USER3> I'm dyslexic. I haven't looked into it in detail, but someone once told me that dyslexia is some kind of problem processing things that are pronounceable. When I was learning Japanese I was amazed how easy it was to read kanji (the Chinese) characters. Apparently processing things that are inherently symbolic (even if you can pronounce them) is done differently. It was like someone lifted a veil. Even now I prefer reading Japanese to English. I suspect if I learned Chinese I would enjoy it even more.

The same goes for languages with symbols. For me, they are an order of magnitude more readable. Obviously people with dyslexia is a very narrow group to design a language around, but I suspect that there are others who also find it easier to think about symbols than words. That's why people design languages in this way (and as someone else pointed out, probably why math has such a large number of symbols).

There are things that are easy to learn and things that are easy to use. Often there isn't as much overlap as you might expect between the two group. For something like programming languages, I'll take easy to use over easy to learn any day. Having said that, I am absolutely sure there are people who prefer having a big block of prose in their code. I see that kind of code frequently as well, so which one is easier to use almost certainly depends on the person.

<comment><USER2> Great insight, thank you for sharing. I'll keep this in mind. Maybe in some cases a middle ground could be finding a way to use less symbols instead of more. Verbosity isn't always desired with symbol or prose.

</comment></comment></comment><comment><USER4> Gluon recently added implicit arguments with the latest release (see [http://marwes.github.io/2018/06/19/gluon-0.8.html](http://marwes.github.io/2018/06/19/gluon-0.8.html)). In spirit it is like modular implicits ([https://arxiv.org/pdf/1512.01895.pdf](https://arxiv.org/pdf/1512.01895.pdf)). This is really exciting because modular implicits represent a pragmatic balance between the flexibility of ML modules and the convenient overloading of type classes.

Another cool feature of Gluon is modules are basically just records. This is a strict improvement over ML modules in my opinion. (See [http://gluon- lang.org/book/modules.html](http://gluon-lang.org/book/modules.html))

Congrats on the recent release!

<comment><USER5> > implicit arguments

Because it worked so well in Scala?

<comment><USER6> What's your opinion of Odersky's scala3 implicit plan?

<comment><USER5> I'm not very familiar with Scala3, but as far as I'm aware implicits are still a core part of the language?

Let me put it like this: I recently applied to two high-profile startups with experienced technical leadership, and they both explicitly asked me if I was a Scala fan. They weren't and made bad experience in the past regarding productivity due to complexity, tooling and developer onboarding, which unfortunately matches my experience. There is some good stuff for certain niches (Akka, Spark etc.), but otherwise I feel like Kotlin is winning.

</comment></comment></comment></comment><comment><USER7> :sigh: I hate function call syntax without parens. It makes code _much_ more difficult to read and, if it supports first class functions, passing around no arg functions is harder than it should be.

<comment><USER8> I hate function call syntax with parens. It makes code _much_ more difficult to read and, if it supports calling functions, calling functions with args is harder than it should be.

<comment><USER9> While I agree the parent could have elaborated more, would you like to as well?

I've never worked in a language without parents for function calls so I share their confusion reading Haskell or Ruby code at a glance.

I don't think a language needs to bend for non-users but being intelligible without knowing the language _can_ I be nice.

As an outsider, the examples:

A(B(C)) A(B,C) A(B)(C)

Could all be valid Python but still communicate a little bit about A B and C. Without parents they'd all look like "A B C". I'm sure it's more obvious if you know those languages.

<comment><USER10> The interesting thing is that in Haskell, the equivalents of Python's `A(B,C)` and `A(B)(C)` are identical: `a b c`. This is because of currying: you're allowed to supply one argument to a function at a time, and you get back a function that takes one fewer argument. So if `add(x,y) = x + y`, then `add(5)` is a function (let's call it add5) so that `add5(y) = 5 + y`, or in Haskelly notation, if `add x y = x + y` then `(add 5) y = 5 + y`. If you write `add (x,y)` in Haskell, then it means a function that takes a single tuple `(x,y)` as an argument.

A(B(C)) would be `a (b c)` or `a $ b c` or `(a . b) c`. The first is the most vanilla way, the second is convenience (basically "evaluate everything after $ first, then plug it in") and the third uses the function composition operator `.`.

<comment><USER11> Nice summary. I would just like to add that `$` and `.` in Haskell aren't part of the language syntax, they're just normal functions/operators, which some people like to use.

We can define `$` ("apply a function to an argument") as:

        f $ x = f x

We can define `.` ("compose two functions") as (where `\x -> ...` is an anonymous function):

        f . g = \x -> f (g x)

Equivalents in, say, Javascript would be:

        function dollar(f, x) { return f(x); }

        function dot(f, g) { return function(x) { return f(g(x)); }

People mostly use `$` because of its precedence rules, which cause everything to its left to be treated as its first argument, and everything to the right as its second, i.e. we can use it to remove grouping parentheses like:

        (any complicated thing) (another complicated thing)

with:

        any complicated thing $ another complicated thing

It's also useful for partially applying, e.g. `map ($ x) fs` will apply each function in the list `fs` to the argument `x`.

</comment></comment></comment></comment></comment><comment><USER12> Looks like a great language that's a nice mix of OCaml and Haskell!

What's the interop story? If I am embedding this language inside my app, I reasonably want to make data structures in my app to be available through this language. How would that work?

<comment><USER13> The support for interop looks strong:

[http://gluon-lang.org/book/embedding-api.html](http://gluon- lang.org/book/embedding-api.html)

[http://gluon-lang.org/book/marshalling-types.html](http://gluon- lang.org/book/marshalling-types.html)

There are some marshalling traits that you can implement or derive.

</comment></comment><comment><USER14> Now _this_ is what every language landing page should be like. I love the nontrivial code snippet solving a fun little problem front and center.

</comment><comment><USER15> Wow, I've been wanting something just like this for Rust. And it has row polymorphism!

<comment><USER16> Arguably, this is Rust.

<comment><USER15> Not sure what you're trying to say here. Gluon is much more like OCaml than it is like Rust. And Rust _doesn't_ have row polymorphism.

<comment><USER16> By being hosted in Rust, Gluon has access to the Rust ecosystem. So one could use Gluon and still be in the family depending how seamless the interop story is.

<comment><USER15> I think we are in agreement. I was saying that I was looking for an embedded programming language like this for Rust, and now I've found it.

</comment></comment></comment></comment></comment><comment><USER17> It would be great if someone made a UI framework with Rust and made this the scripting language (making the experience Elm-like, but with a better type system and without web technologies)

</comment><comment><USER18> Too bad it has a different heap per thread. If I want to extend a C (or rust) posix-multithreaded program, it means I can't easily use gluon to access the state of my program (which requires accessing posix-multithreaded protected variables in the normal heap). Same thing that makes Lua useless to simply extend actual, pre existing C programs.

Anyway, I'm still happy to see that more modern languages than algol have gained enough influence than the choice of type system, type inference and non C like syntax is not frowned upon anymore.

</comment><comment><USER19> Looks like F# but has a big design mistake in my opinion (which F# doesn't): the symbol '=' in a functional programming should be tied to comparison, not assignment. (The approach taken here is using "==" for comparison, which is less ugly than JavaScript's "===" but still ugly.)

</comment><comment><USER20> As the `in` keyword seems key to understanding the language, could someone elaborate on it?

It isn't obvious after reading the intro on [http://gluon- lang.org/book/syntax-and-semantics.html](http://gluon-lang.org/book/syntax- and-semantics.html).

<comment><USER21> Looks like a variant on ml-like `let`.

        let <variable> = <expression 0> in <expression 1>

will bind the value of expression 0 to variable in expression 1.

</comment></comment><comment><USER22> So many new languages lately, does anyone is risky enough and using such languages in production?

</comment><comment><USER23> This looks very similar to Nix, with improvements such as real typing and lack of semicolons. That's a very good thing.

Any plans for a purely-functional variant (i.e. a single expression per evaluation)?

<comment><USER24> According to the manual, Gluon doesn't have statements, but it elides "in":

       let n = 1
       let m = 2
       let nm = n + m
       nm

is sugar for

       let n = 1 in
         let m = 2 in
           let nm = n + m in
             nm

</comment></comment><comment><USER25> I feel like every day a new programming language presented on HN. Maybe you didn't realize, but we know CL/scheme/clojure already and have no turning back..</comment>


Ask HN: Who is behind the Linode DDOS attacks? - <AUTHOR> The past couple of days have shown massive DDOS attacks against various Linode datacenters. Who could be behind these attacks?<p>Ref: http://status.linode.com/ <comment><USER2> You'll probably find that they're targeting one of Linodes customers rather than the actual Hosting company.

As for the reason, it's normally trying to get money out of them, or just to take a website offline for a while (e.g. the DDoS is from a competitor).

Most attacks will continue until you can prove that your no longer affected by them and can clean out the dirty traffic, this is quite expensive to do though.

<comment><USER3> I don't think they're targeting customers, because they have attacked almost every datacenter... strange behaviour...

<comment><USER4> It's possible they are attacking the hosting company BECAUSE of a customer they are hosting. We get these all the time -- they attack the customer and then when they can't take it offline they get angry and attack/threaten the hosting company's infrastructure.

</comment></comment></comment><comment><USER5> I am surprised they were not prepared, our servers were down for 4 hours.

<comment><AUTHOR> Who can handle this scale of an attack?

<comment><USER6> Nobody.

Because when a hosting company scales up its network to withstand an attack, many other companies do the same. And the attackers open accounts at several companies to launch the attacks.

If you can distribute all your services including DNS, across several providers, then you can probably withstand the attack yourself.

Whatever you do, the attackers will learn and evolve. So the best you can do is to get the pain down to a level that you can withstand. Only when everybody does this, will the attacks stop, or more likely, move to another venue.

</comment></comment></comment><comment><USER7> I'd like to know! I was wondering this myself...

</comment><comment><USER8> Me!

</comment><comment><USER9> ISIS did it</comment>


Startup discipline and family--any hilariously-frustrating fun stories? - <AUTHOR>

Hi gangs,
I've been a lurker mostly for a long time, but decided to start an account recently to contribute to the community more actively.
I quit my day job not too long ago (about over a month) to start on my own project. At first it was always 16 hours a day and really getting things done. For the last few weeks or so, my young wife has this trick: "If you don't want to go to sleep with me, you don't have to, but come put me to sleep/tug me in first."  And I ALWAYS fall asleep with her.
I guess the hilarity of it all is that I would wake up at 7 or 8 realizing: "Aarrrggh! she did it again!" or "Oh noes, I've fallen asleep and I didn't get up!" And we would have a good laugh about it. But I'm getting a bit hilariously ...frustrated.  I love spending time with the young wife, but gosh, I got to go conquer the world.
We have this thing where she would ask me every day before heading out to work: "What are you planning to do to day?" and I would answer: "Same thing I do everyday, Pinky, try to take over the world."
It has been about 40 days, and I'm only done with all the back-end functionalities--I guess I'm hoping to get to work on the design and front end this week.
What about you? any frustratingly fun stories? I'd love to hear stories about what you guys have "endured" with your oh-so-lovingly-but-clever trickster family/partner/pet ?
Graciass,
-V.
PS: by the way, I'm 28, but someone on #startups was saying I might be a bit old to do this whole startup thing. Heh, I thought that was sort of funny, but any take on that? Bootstrap startup sure has its ups/down, eh?! :) <comment><USER2> If it's 40 days of that kind of workload and you're only just done with the backend, your Minimally Viable Product likely has too many features.

Strip it down, launch with less.

I am in the process of kicking my girlfriend out of my house for this very reason. I'd rather be single and taking over the world than getting snuggly full nights of rest.

<comment><AUTHOR> I definitely keep going back to my MVP plan to cut down the scope-creepiness so-to-speak part of my work. It's getting better.

Are you breaking up with your girlfriend to do startup? That's a bit of an extreme case isn't it? I could understand if there is implication of bigger issues--but the world is quite a lonely place without people, my friend.

I wanted to commit to startup/entrepreneur life for 2 reasons: I can't live without it and I want to take care of my family with the rewards :) You can't possibly conquer the world without love ones' support. It is such a lonely path, being entrepreneur, already. Any love a long the way would only enhance it.

By the way, some might trade everything for a snuggly full night of rest.

Stay enthusiastic, my friend and good luck.

<comment><USER2> For now I'm just kicking her out to avoid distraction, we'll see about full-on "breaking up" later. I have plenty of people in my life, but I need them to stay inside their time-boxes if I'm to get anything real accomplished in this short life I have.

It's no so much "to do a startup" - I think the "go to work"/"do a startup" dichotomy espoused by so many on HN is a bit of a meaningless construct. I already have a fairly successful business that I started, but I'm always working on several other projects (some revenue, some not) at any given time.

Most of my ideas are the kinds of things that are somewhat market-timing- critical, so there will be quarters in which I am "only" working 50 hours a week, but sometimes during a rush to get a product out, I will double that. I don't really count hours - it's one of those things where you're either sleeping, eating, or moving toward a goal. It seems perfectly natural to me, and it certainly doesn't feel like work.</comment></comment></comment>


Coderacer: interactive coding game from the treehouse team - <AUTHOR> http://coderace.me/

<comment><USER2> It shouldn't require a Facebook account.

<comment><USER3> As far as I know, it IS a Facebook app in the sense that it uses the Facebook API to connect you to other Facebookers who want to code race against you.

Bummer since it's a great idea but I deactivated my Facebook account a couple months ago...

</comment></comment><comment><USER4> Looks interesting, but...

"To play Code Racer, you'll need to login with your Facebook account."

Too bad, I'll pass.

</comment><comment><USER5> Very cool concept, and I would play, but seeing as a huge chunk of my friends that code don't use Facebook, it just doesn't seem worth bothering with right now.

<comment><USER6> The app pairs you up with random people. AFAIK you're not able to choose with whom you play.

<comment><USER5> Ah, ok. Going to have to look into it more then.

</comment></comment></comment><comment><USER7> I'm so proud of the Treehouse Team for building this in four days! :)</comment>


Stripe vs. Paymill - <AUTHOR> http://9elements.com/io/index.php/stripe-vs-paymill/ <comment><USER2> I have been working with, and implented, both Stripe and Paymill. I agree with the article that the only time you would go with Paymill is simply if Stripe is not yet available (and in those cases you are probably better off with a local competitor).

Paymill is just a bad copy of Stripe in regards of technology, customer support, processes etc. One example of this is the ID verification process. Stripe has this automated and it takes minutes to complete. With Paymill we had to send copies of several different ID documents to different people and the process took weeks.

<comment><USER3> Second that, exactly same experience. Plus Stripes API is awesome. If you want to move fast, avoid headaches, pay less fees, go with Stripe.

<comment><USER4> I've had a much higher conversion rate with PayPal, even though I love stripe. It's annoying, because it's hard to do add-on payments with PayPal. Stripe is basically a dream to work with. But, if you don't have PP, you should -- but then once you do, it torques your conversion numbers per platform because people just see the PayPal button and click it. Suddenly 90% of your sales are through PP. The fact is: no one wants to type in their CC numbers and all that nonsense. Convenience factor is huge.

It's not sensical to choose one or the other over which YOU like more. You're in business to increase profits. If that means a PayPal button, so be it.

<comment><USER5> Hm, this is very interesting to hear, and doesn't match the what we see in general or what PayPal apparently sees in aggregate[1].

I'd be very curious to hear more about your use case -- could you drop me a line? firstname.lastname@example.com.

[1] [http://www.quora.com/Online-Shopping/When-purchasing- online-...](http://www.quora.com/Online-Shopping/When-purchasing-online-do- consumers-prefer-using-PayPal-vs-a-credit-card)

</comment></comment></comment></comment><comment><USER6> One big difference between the two is that from what I understand is that with Stripe you use a shared merchant account where as with Paymill everyone get's their own. This explains why with Stripe you can be approved in minutes where as Paymill can take up to a few months at times.

<comment><USER5> > _One big difference between the two is that from what I understand is that > with Stripe you use a shared merchant account where as with Paymill everyone > get 's their own._

(I work at Stripe.) What it even means to have a "merchant account" is shifting in the industry, so it's hard to be absolutely definitive, but: most of Stripe's transactions run through what would traditionally be designated as regular merchant accounts. At the same time, it's our belief that it shouldn't _matter_ (which is why we don't expose this). There are properties that our users should care about -- that funds are held in their name, that the right thing appears on cardholders' statements, etc. How that's accomplished is an implementation detail that may change over time and which will depend on the payment instrument, country, and so on.

<comment><USER4> Great reply with just the right amount of transparency, technical detail, and candor. Pretty much what we've come to expect from Stripe :)

</comment></comment></comment><comment><USER7> The sole advantage Paymill has is that you can make use of it from any EU country. That said my experience with them was horrific. If Stripe continues to expand, I doubt that Paymill will be around in a few years.

Instead of the 10 days approval period they advertised I got hit with almost three months. Some of the delay was caused by Wirecard, the bank they work with. I can sort of relate to that. However the significant delays caused by their own contract manager left me baffled. On average her email replies were delayed by 3 to 4 days. Worse the emails were written without much thought. A slow trickle of unhelpful messages that slowly erodes your hopes.

Was she overworked? Or in need of training, I don't know. But for certain the future is bleak for Paymill, unless they drastically improve the on-boarding process.

<comment><USER8> So what exactly was "horrific" about the experience?

</comment></comment><comment><USER9> > Both services are providing solid libraries and gems for every major > programming platform like Rails or Node.js.

Laughed out loud at that one. :-D

</comment><comment><USER10> I am not sure about Stripe since it is not available in our country (Slovenia), but Paymill doesn't allow processing 3rd party payments. Plus it took them 57 days from the day we sent them paper documents (they travel max 5 days to Germany) to respond that they cannot help us (since we do 3rd party processing). I was not impressed by their customer support and look forward to the day when Stripe will become available.

</comment><comment><USER11> [https://stripe.com/prohibited_businesses](https://stripe.com/prohibited_businesses)

Just have a look at this list, there are enormous markets which are not served at all by stripe.

<comment><USER12> I honestly wonder how big these markets are..

      > 17. Bankruptcy lawyers

      > 37. Mail-order brides

<comment><USER13> > 37\. Mail-order brides

As was just pointed out to me, that means mail-order _husbands_ are not forbidden. Just in case anybody was planning on starting a new business.... :)

In all seriousness, some of these other markets _are_ massive industries, but are excluded for good reasons - I recognize a number of them immediately as being disproportionately high targets for fraud and/or chargebacks, which would be prohibitively expensive for Stripe to deal with right now.

</comment></comment></comment><comment><USER14> There is nothing to compare here. One company has a vision and a goal and the ability to execute on those. The other is a clone. They will always be second, they will always follow through, they will not innovate. That's for most clones.

<comment><USER15> So? A payment processor is, in many ways, a utility. There's only so much innovation I need out of Stripe - they need to process payments for me. Done. If a competitor is cheaper, it's valid to go for them.

<comment><USER16> Yeah. Ultimately they're both trying to deliver incremental improvements to the developer-friendly full-stack payment platform model that had already been validated by Braintree as an incremental improvement on payment platforms that had been around since before the internet. It's updating an old, unfashionable industry for an audience in a particular part of the world, not making "a game that looks a bit like Foo" or yet another Groupon clone. Being incubated by Rocket Internet doesn't necessarily make you a vastly worse-run company than being incubated by YC.

<comment><USER17> The difference is the way it took to get where they are, technically speaking. On one side, they chose to architecture their SDKs/APIs in a way for some reasons, after some thinking. And they are going to keep improving on it in a consistent way. Same thing for customer support. On the other side: "Hey, it works for them, let's not think, throw $10M and do the same!", but I don't think it's possible to improve the product when you just rely on the innovation on someone else. Until now, the only valid reason that made people chose Paymill was that they were available in Europe, but Stripe is going to change that soon.

One other good example to show how good rocket internet is: Here is a french website: [http://www.adopteunmec.com/](http://www.adopteunmec.com/) (you can translate it by "adoptaguy.com") And here come RI in Germany: [http://www.shopaman.de/](http://www.shopaman.de/), looks familiar?

</comment></comment></comment></comment><comment><USER18> I'm in the process of integrating with Paymill. I can't say much of the service itself yet, but they are trying to help with the registration process, even calling me when needed. I'm optimistic for now.

<comment><USER19> Why did you choose them over Stripe?

<comment><USER18> I didn't, Stripe chose Paymill for me by not being available in my country.

</comment></comment></comment><comment><USER20> Paymill is _even more_ expensive than Stripe (as 0.28€ is $0.39), which was already "way too expensive for product whose only value over PayPal seems to be prettier documentation" (especially at the under-$12 price point that most of these digital goods are at, but even at larger points as PayPal will give you bulk pricing on orders-of-magnitude smaller transaction volumes). (I guess maybe with larger transaction ticket pricing the cross-border 1% from PayPal will be higher than the $0.09 fixed-fee different from Paymill? Is that the idea?)

</comment><comment><USER21> I run a very large adult website and wanted to integrate Stripe as the payment solution for subscriptions but like most payment processors in the United States they refuse to work with adult sites. Ironically PayPal is more accepting than Stripe and DOES work with adult sites (under certain conditions). Stripe on the other hand does not under any circumstances. I know adult websites are taboo, but it's really hard to find a payment solution that is as easy to use as Stripe. Does anyone know if Paymill fills that void?

<comment><USER22> Depends, but it doesn't seem hopeful - looking at their T&Cs at:

[https://www.paymill.com/en-gb/terms-conditions/](https://www.paymill.com/en- gb/terms-conditions/)

Section 9.1 includes, amongst other excluded categories, "Sales of erotic articles". I suppose the only way to get an authoritative answer would be to describe your situation to them, and see whether they'll accommodate you.

</comment></comment><comment><USER23> Why is it taking Stripe so long to come to EU? Any idea when they will be available across EU?</comment>