Django 1.5 released - <AUTHOR> https://www.djangoproject.com/weblog/2013/feb/26/15/ <comment><USER2> Wonderful! I just want to extend a heartfelt "thank you" to all the guys and gals contributing to Django.

Django is still a cornerstone of our startup and we're way past the point where folks have traditionally said "Django starts to constraint you". We've found that to be untrue. We love the templating, the ORM and all the built-in tools (not to mention 100s of libraries that get you an 80% finished feature in 5% of the time).

I hope to meet a lot of you at Pycon, I'd be happy to buy you a beer. I'll be wearing the bright orange Zapier shirt, you can't miss me. :-)

<comment><USER3> I wonder if perhaps your people just don't have much exposure, because the templating in Django is awful compared to Mako/Jinja2, the ORM in Django is awful compared SQLAlchemy, and most of the useful features of Django are easily available in Pyramid or Flask, yet these systems are unobtrusive and simple. Django has a monstrous "middleware" piece and a bunch of other cruft that is really just bothersome dead weight. It's not that there's no use for it, it's just that similar things are accomplished in much more concise, fast ways in other frameworks.

Not to hate on Django, jacobian, or the LJ-World, I appreciate the effort put into the system. But I don't think it really has much to offer in present-day for people developing new, serious platforms. I feel the same way about most other "full-fledged" MVC frameworks, because they all seem to far exceed what ought to be the logical bounds of their influence. In many cases you feel like you're writing Django, Cake, or Rails and not writing the actual language based on, because these frameworks mandate so much and require special integration to do much of anything. In something like Pyramid, you write Python, and Pyramid provides the pieces that make it easy to bundle together and publish as a website.

I've had positive experiences with Sinatra, too. "Microframeworks" and close cousins like Pyramid are really much more appropriate dev platforms, imo: modular, unpretentious, exist simply to help you get your program onto the web in a fast, concise, and simple way, without attempting to inject a rewrite of the standard lib or force you to conform to their unique flavor of MVC, their crappy ORM, etc.

<comment><USER2> One might easily take offense at your comment:

> perhaps your people just don't have much exposure > new, serious platforms

Both could have been omitted and your points would still have been valid.

Anyways, I'm not advocating Django as "the one true way", just stating that is hasn't hindered us in the least. :shrugs:

<comment><USER3> I don't intend offense. I'm just suggesting an explanation for why you may feel Django is not problematic. When all you have is a hammer, everything looks like a nail. I've met many-a-programmer fairly early in their careers who praise things like Cake, Rails, or Django, but in my experience at least, as they mature, they prefer less invasive solutions.

<comment><USER4> In a few years you'll probably get to the point where you don't prefer less invasive solutions but will pick the right tool for the job.

If you know you'll be iterating rapidly but will stay within the confines of 'standard CRUDdy app' then e.g. Django, RoR, Spring Roo e.a. will be probably be good to you. If you expect to go beyond those confines you'll be burnt.

In general it's about finding what I like to call the 'grain of the tool' and pick the ones where you can go with the grain.

<comment><USER3> I prefer less invasive solutions because they are generally the right tool for the job for serious web platforms, which is the niche to which I limited my comments. And for the record, I've been around for some years.

If I just want a basic CRUD app that will basically never exceed the capabilities of Django's automatic admin interface, then sure, Django will be fine for that because all I'll have to do is define models and I'll be done. I can then query the SQL database directly if necessary, or write a separate application that generates reports on the data.

Most "serious platforms", however, do much more than this. For platforms that run companies, least-invasion is a good principle, because it allows you to adapt quickly as changes are necessitated. Django, Rails, et al often world- break if you try some "funny business". Next-gen frameworks like Flask and Pyramid have almost no reasonable condition that qualifies as "funny business" from the framework's perspective, so they're much easier to iterate upon or pivot from.

<comment><USER4> > serious web platforms, which is the niche to which I limited my comments

That is exactly the kind of grain I was talking about.

If you were running a startup that's focusing on finding product-market-fit and quickly iterating on the UX to get conversions up and attrition down Django (or RoR) might be a better fit.

When you start outgrowing Django you can just start splitting off components and rebuild them in a more 'serious' way.

<comment><USER3> I disagree, because you can iterate just as quickly with Pyramid/Flask, generally speaking.

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER5> Hot dog.

I've been working on a small side project the past week or so using the 1.5 RC and following along the best practices recommended by 2 Scoops of Django -- <https://django.2scoops.org>

If you haven't already, I highly, highly recommend picking up the 2 Scoops book. It's got some great, proscriptive advice and is an easy-to-follow roadmap that helps answer a lot of "what is the right way to do this?" kinds of questions. Setting up your settings files for multiple environments, using CBV's, understanding the new User Model features, writing tests, recommended 3rd party tools, securing your setup -- these things are all a lot more clear to me.

And it's actually really well written, not just a bunch of recipes. Their explanation of mixins, for instance, is one of the clearest, most concise I've ever come across. Well worth $12 and a few hours of time to read through it.

<comment><USER6> Thanks for posting about this book, I've been meaning to get into Django for a while, but I didn't find the official tutorial to be terribly enlightening beyond the basics. Plus there's a whole heap of non-code related environment stuff which I want to have best practice for too.

If anyone knows of any other good first-up books / websites (are there any interactive tutorials Treehouse / Codecademy style?), please let me know.

<comment><USER5> Fair warning: 2 Scoops definitely assumes some familiarity with how Django works, specifically models, views, templates, and forms. It won't introduce these concepts to you but will help you use them better.

The official Django Tutorial is still a great starting place for getting your head wrapped around that stuff -- <https://docs.djangoproject.com/en/dev/intro/tutorial01/>

<comment><USER6> Thanks, I worked through the tutorial, so I know the basics I suppose. But I got to the end and wanted it to keep going, so I guess this book will come in handing for learning beyond the official tutorial.

I'm also going to check out <http://gettingstartedwithdjango.com>

<comment><USER7> If you're interested: I wrote an extended follow-up to the 1.4 tutorial that is a bit more real-world: using South for migrations, bootstrap templates, learning to use the forms library, adding popular apps like debug-toolbar and so on, writing annotation and aggregation queries, etc. See the "courseware" link at <http://simeonfranklin.com/pro-django-class/>

<comment><USER6> I'll check it out, thanks!

</comment></comment></comment></comment></comment></comment><comment><USER8> _> Django 1.5 is the first Django release with support for Python 3 (specifically, Python 3.2 and newer)._

That sentence is of course followed by caveats about Python 3 support being experimental at this stage, but all-in-all I think this is a sign that we are finally at the tipping point for Python 3 to start gaining mainstream usage.

Thank you Django community for moving the ball forward for everyone.

<comment><USER9> FYI, the "experimental" thing is a community thing, not really a technical judgement. Since this is our first Python 3 release, we want to have some space to make changes between 1.5 and 1.6 that we otherwise would avoid because of our strong backwards compatibility promise. The "experimental" label is about giving ourselves that room and not surprising users if there do have to be changes in the way Py3 support works between 1.5 and 1.6.

Technically, however, it's pretty rock-solid. I'll be launching a site built on Py3/1.5 is about two weeks, and aside from constantly forgetting to `print(...)` instead of `print ...` it's been surprisingly smooth sailing.

<comment><USER10> Have you found any of the third-party Django extensions to be catching up? I'm starting a new project and would _love_ to just start with Python3, but there are a few packages I depend on: South, lxml, pytz, simplejson, requests, django-compressor, gunicorn, jinja2, twisted, txAMQP, and django-rest- framework (amongst some other utilities actually used for development).

It would sure be great to have a list of django sub-projects and their Python3 status.

Regardless, even if we start with Python2.7 and bump up to 3.3 in a few months, this is a _great_ step!

<comment><USER9> Of your list:

* South doesn't have Py3 support in core, but there's a fork that does and seems to work perfectly: <https://bitbucket.org/aaugustin/south-python3>

* lxml as of v3 seems to have py3 support (I haven't tried it, but looks like it does).

* simplejson is now in the standard library as "json", so yes there.

* requests works, since v0.10 (about a year ago).

* django-compressor is not ported; however, django-pipeline does run on Python 3 and is basically -compressor's successor. It works great.

* gunicorn works on py3 (as does uwsgi and mod_wsgi, btw.)

* jinja2 hasn't been ported yet.

* twisted is actively being ported right now, and has gotten to the point of "kinda working". You can follow along at <http://twistedmatrix.com/trac/milestone/Python-3.x> and <http://twistedmatrix.com/trac/wiki/Plan/Python3>.

* txAMQP probably can't get ported until twisted does.

* django-rest-framework has Python 3 support, I think it's fairly recent, but it works well.

This list is about typical of what I've found doing Django/Py3 work: many things are ported, a bunch more have good alternatives, and a few things are still missing.

</comment></comment></comment></comment><comment><USER11> > _Django 1.5 introduces support for a configurable User model. The basic > Django User model is still around, of course, but now there's first-class > support for specifying your own model and having Django's auth system make > use of it._

I guess having it be a special User model is just part of the deal with Django's good out-of-the-box admin. I don't even remember how the various Rails plugins (ActiveAdmin, for example) generates the scaffolding needed for an authenticated user.

<comment><USER12> Not just contrib.admin, but also contrib.auth.

It's very easy to extend the existing user model rather than creating one from scratch. I had to do some unconventional auth stuff recently and I only extended auth.User slightly (and also wrote a slightly modified authentication backend).

<comment><USER13> This feature was something we'd hoped would be awesome; it's not. Going over the documentation shows there's some jaw-dropping nastiness you have to go through to make it work.

It's good that they're providing it, but I think the complexity is going to turn people off (I know I won't be using it unless it's simplified at some point in the future). User profiles have always been used for adding data to User models indirectly, and I think this is probably going to remain the best way to handle it for most uses.

<comment><USER14> Can you expand on the "jaw-dropping nastiness you have to go through to make it work"? Seems pretty straightforward, though I have not tried to actually use it yet.

[https://docs.djangoproject.com/en/1.5/topics/auth/customizin...](https://docs.djangoproject.com/en/1.5/topics/auth/customizing/#auth- custom-user)

It appears the database migration is the biggest hurdle, but I don't think there's a way around that. User profiles require a join and that can be suboptimal, which is why this is a useful addition. If you weren't running into problems before it's probably better to not change (though that's usually the case for working code).

<comment><USER15> I can't speak for obviouslygreen, but I recently implemented the new User model and was a bit surprised by all the stuff I had to do myself.

I just wanted to add one field to the user model, but to do that I had to add 100+ lines of code.

I am very happy custom User models are possible now––but for most stuff I'll probably keep using a UserProfile.

<comment><USER16> What field were you adding? Are you aware of django.contrib.auth.models.AbstractUser?

</comment></comment></comment></comment></comment></comment><comment><USER17> There's a lot of hype around the new configurable User module. But personally the new verbatim template tag is golden:

[https://docs.djangoproject.com/en/dev/ref/templates/builtins...](https://docs.djangoproject.com/en/dev/ref/templates/builtins/#std:templatetag- verbatim)

<comment><USER14> It is, but was an easy addition before. If you needed a configurable user module before you were up the creek.

</comment></comment><comment><USER18> It's great to see the Django tutorial extended to cover testing[1] and writing reusable apps[2]. These days there are quite a few Django tutorials out there covering best practices etc. (which are very good) but I would still recommend the official Poll app tutorial to any beginner because of it's simplicity.

[1]: <https://docs.djangoproject.com/en/1.5/intro/tutorial05/>

[2]: <https://docs.djangoproject.com/en/1.5/intro/reusable-apps/>

<comment><USER19> Unit testing Django applications has been a source of pain for me. Writing functional or acceptances is ok using Django test client, although many recommend using WebTest, which is nice but slow if you're going to write hundreds of them.

<comment><USER18> I agree about the slow running time of Django tests although I have found that using sqlite database backend for tests reduces the time significantly.

</comment></comment></comment><comment><AUTHOR> Release notes: <https://docs.djangoproject.com/en/1.5/releases/1.5/>

</comment><comment><USER20> Sorry for the Off topic, but anybody have a good experience with Appengine+Google Cloud SQL+Django?? I am thinking as alternative to AWS but I dont know if it's going to give me so much problems with the integration. Also a bit worry about the price in comparation with AWS. Anyone experience in both world?

<comment><USER21> I have used both. I would strongly suggest going with AWS.

Reasons:

Local development with Appengine is pretty bad. Good luck debugging and profiling production issues.

Appengine will make you jump through many hoops that undermine or completely drop pieces of the Django framework.

Getting data out of Appengine is a huge nightmare and timesink.

If you ever decide to migrate off Appengine you will need to rewrite almost everything.

<comment><USER22> Was your data in the Appengine Datastore? I believe elicox was asking about using Google Cloud SQL, which I believe makes data export relatively easy (Cloud SQL is basically managed MySQL). New Django + Cloud SQL also runs basically "pure" Django, rather than the hacked-up djangoappengine of the past, so next to zero code should have to be changed in a move off AppEngine.

I recently made the switch from Datastore/djangoappengine to Cloud SQL, and it has been a far better experience.

<comment><USER20> Yeah I mean Cloud SQL, few years ago i was trying to replace the ORM of Django with he own AppEngine Datastore and it's a nightmare.

</comment></comment></comment></comment><comment><USER23> So, I'll ask the noob question that has previously been getting asked to death but there's finally new reason to ask once more: someone who's had little to no prior experience with Django, and still is very much a novice with Python -- do you suggest they start using Django with Python 3 or 2?

<comment><USER24> Python 2

I really, really wanted to say to you Python 3, because:

\- It is better (it fixes some annoyances)

\- Django is working really great with it

But some things (that Django uses, but are not Django) are not working yet. Things like MySQL adaptors, South, etc

Or maybe go with Python 3 and wait for the issues to be fixed, they probably will, soon enough

<comment><USER25> The Python 2 v 3 conundrum seems to have been going on for an eternity. It must be putting off new adopters in their droves. For a start, you have to make an important decision about which flavor to install and how to get started right at the beginning, with no canonical right answer to the dilemma. Do the great and the good in the Python community realize how damaging this is, and how such a thing should never ever be allowed to happen again ?

<comment><USER26> How do you propose this be implemented? By abandoning Python 3, or shooting the dissenters who still insist on Python 2?

<comment><USER25> I have no idea what to do about 2 v 3 now. The grandparent is a genuine question, and my perspective is as a casual sometime Python user rather than a serious Python user. I am personally frustrated by the problem every time I'm tempted to get serious about Python. I'd love to know whether the key Python people acknowledge the problem in the way I've framed it and whether they have resolved to avoid something similar happening again in the future once this issue (finally) works itself out one way or another.

</comment></comment></comment></comment></comment><comment><USER27> I'm super excited about this release but I really, really envy the Russian Doll-caching through key-based expiration and the Turbolinks of the Rails 4 release. Man I really wish django would package all the JS magic Rails comes with.

<comment><USER28> Are there any mature 3rd party apps that cover this ground?

<comment><USER27> Not that I have found so far.

</comment></comment></comment><comment><USER29> Does anyone know what the status is on the non-rel branch? It's still on 1.3.

What framework do other people using NoSQL data stores use?

<comment><USER2> It is highly unusual to use NoSQL as the main data store in Django (so much of the built-in functionality requires relational databases, so you end up net- negative). Most Django folks augment their relational database with some NoSQL bits.

We've been big fans of storing core data in Django models, but using things like key/value stores to store random extra bits that aren't exactly _core_ to the model. Redis is great for this, or another model as triple store style GenericRelation if you need to query on it.

I don't imagine the nonrel branch will move again, its such a departure from core Django. Look into using Flask, as there aren't many "mature" frameworks that do NoSQL core.

<comment><USER30> What about hstore?

<comment><USER2> I've _very_ limited knowledge about hstore, but have only heard great things!

</comment></comment></comment></comment><comment><USER31> Django 1.5 unchained

<comment><USER32> I _hate_ that movie. I've never seen it but now it's the first page of search about half the time when I'm googling development issues with the real Django :-)

<comment><USER11> Maybe it's Google Search biasing towards me (or at least my IP address), but Django, the framework, should be proud that it's keeping the top rank for that search term despite the buzz around Django, the movie (which, even though I love QT, was a pretty sloppy movie, IMO).

The real loser is Django Reindhardt, who Adrian Holovaty named the framework after, and is now bumped off the first page of Google results.

<http://en.wikipedia.org/wiki/Django_(web_framework)#History>

</comment></comment></comment><comment><USER33> Is it just me, or is it simpler to go back to wsgi middleware plain and simple?

I am getting turned off left right and centre by frameworks - Django and even Flask just make reasoning about the request/response more difficult.

Maybe I don't know how to use this but ... It would take me three months to read the new Django docs.

I am not a hater here, just wanting the simple life

<comment><USER34> I get this feeling about Django, but not about Flask. Its codebase is so lean I can read all the relevant parts in an hour when I want to get back into it. I don't even need docs for this thing.

However, I understand what you mean about request / response, I don't like how this is handled in most python frameworks actually, it's usually too much abstracted away.

The nicest (imperative) environment for asynchronous execution I've seen is Objective C/Cocoa for some reason. It has a way of showing you all the handles you might need, but it also makes it fairly obvious when and how these handles are called. Together with lambda support ('blocks') it's simple but effective.

I think the main difference is enterprise + closed source + well documented environments vs. opensource + not so well documented environments often originating from someone's hobby. When it comes to big middleware frameworks I prefer the first, but small lean stuff such as Flask is just fine to use IMO.

My advice is to not rely too much on the docs when you want to really know something - take a look at the source, it's all there.

</comment></comment><comment><USER35> The django-firebird (fdb driver) is now available for installing via pypi. Just run: pip install django-firebird <https://pypi.python.org/pypi/django- firebird> It's developed for django 1.5+

</comment><comment><USER36> What do Python frameworks like Django need to do to start taking market share from Rails?

<comment><USER37> Increase the price of cpu's and memory.

</comment></comment><comment><USER38> Slightly OT: How does python2 and python3 usage numbers compare?

<comment><USER39> Anecdotal: I wrote a Google Reader API library in Python 2 that I'm working on porting to Python 3 and it really hasn't been that bad. I had some HTTP dependancies on urllib/urllib2 but requests (with a py3 compatibility class) made it easy.

The port was requested by someone looking to build an RSS feed reader or checker in Sublime Text 3, which using Python 3.3. Things are moving forward.

<comment><USER40> Hey, that was me. Glad to hear it :)

<comment><USER39> Howdy! I have a branch with all the tests working, just haven't made an official release yet. Hopefully very soon...

</comment></comment></comment></comment><comment><USER41> On the Python 3 subject, I'd be highly interested in seeing if there any performance wins by switching your Django deployment to Python 3 over something like Python 2.7.

<comment><USER42> If you go 3.3:

* If you use decimal module, you will benefit from the serious speed improvements (<http://docs.python.org/dev/whatsnew/3.3#decimal>).

* The memory usage of strings is slightly lower ([http://docs.python.org/3/whatsnew/3.3#performance-and-resour...](http://docs.python.org/3/whatsnew/3.3#performance-and-resource-usage)).

</comment></comment><comment><USER43> I hope this isn't too difficult to upgrade to from 1.4 Also, I'd like to thank all of the Django contributors for their excellent work and for making my job easier!

<comment><USER44> Easy to upgrade: hardly. Easy to migrate. weeell ...

#django on FreeNode is pretty good, though.

</comment></comment><comment><USER45> Im new in django and i fell in love with it. nice update. :D

</comment><comment><USER44> Looking forward to see if there'll be any SQL query improvements after I play around with the new User model and improved object fetching.</comment>


Sometimes MySQL is more standards-compliant than PostgreSQL - <AUTHOR> http://ocelot.ca/blog/blog/2013/09/30/sometimes-mysql-is-more-standards-compliant-than-postgresql/

<comment><USER2> Re "Character Sets And Collations", VARCHAR means variable length. It does not mean "automatically strip blanks" SQL-92 8.2(3) [1]:

3) The comparison of two character strings is determined as follows:

                a) If the length in characters of X is not equal to the length
                  in characters of Y, then the shorter string is effectively
                  replaced, for the purposes of comparison, with a copy of
                  itself that has been extended to the length of the longer
                  string by concatenation on the right of one or more pad char-
                  acters, where the pad character is chosen based on CS. If
                  CS has the NO PAD attribute, then the pad character is an
                  implementation-dependent character different from any char-
                  acter in the character set of X and Y that collates less
                  than any string under CS. Otherwise, the pad character is a
                  <space>.

                b) The result of the comparison of X and Y is given by the col-
                  lating sequence CS.

                c) Depending on the collating sequence, two strings may com-
                  pare as equal even if they are of different lengths or con-
                  tain different sequences of characters. When the operations
                  MAX, MIN, DISTINCT, references to a grouping column, and the
                  UNION, EXCEPT, and INTERSECT operators refer to character
                  strings, the specific value selected by these operations from
                  a set of such equal values is implementation-dependent.

Other implementations:

MSSQL has a padding option for this [2]

Redbrick docs state "A character string stored in a VARCHAR column has exactly the same length as the source string or the expression that generated the string (including trailing blanks). Character strings stored in a VARCHAR column can vary in length" [3]

[1] [http://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt](http://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt)

[2] [http://support.microsoft.com/kb/316626](http://support.microsoft.com/kb/316626)

[3] [http://publib.boulder.ibm.com/infocenter/rbhelp/v6r3/index.j...](http://publib.boulder.ibm.com/infocenter/rbhelp/v6r3/index.jsp?topic=%2Fcom.ibm.redbrick.doc6.3%2Fsqlrg%2Fsqlrg17.htm)

</comment><comment><USER2> Wow, what a bunch of MySQL apologist fluff, and half-hearted attempts to prove the authors own point. For example:

"PostgreSQL rolls back the entire transaction when it encounters a syntax error. MySQL only cancels the statement. Now, PostgreSQL is within its rights -- the standard says that an implementor may do an "implicit rollback" for an error."

 _may do an implicit rollback_ \- the standards do not even apply to this argument.

You could replace PostgreSQL in this post with any of MSSQL, Oracle, DB2, or similar, and find standards that are applied in one but not the other.</comment>


Show HN: A Micro-Savings and Investment Crypto Platform for Africa - <AUTHOR> https://ppexchange.herokuapp.com <comment><AUTHOR> The platform is only open to Africa for now, we are working on getting it ready for the US.</comment>


Building highly available applications using Kubernetes new multi-zone clusters - <AUTHOR> http://blog.kubernetes.io/2016/03/building-highly-available-applications-using-Kubernetes-new-multi-zone-clusters-a.k.a-Ubernetes-Lite.html <comment><USER2> Disclosure: I work at Google on Kubernetes.

We're really excited to be announcing this support, it makes multiple zone Kubernetes really straightforward. Please let us know what we can do better!

<comment><USER3> Will GKE offer any of this multi-zone capability for nodes, or is the plan to wait for 1.3 to offer any more availability options there?

I imagine there is some way to do this yourself today by just adding nodes with the right labels and startup script, or even referencing the same images as the google-managed instance group for the cluster, but it feels like that would take away the ability to upgrade the nodes using the google tooling?

Thanks! Really loving the kubernetes ecosystem and appreciate the activity here on HN from the google team members...

<comment><AUTHOR> From the article:

> Though we highlight GCE and EC2, this functionality is available in any > Kubernetes 1.2 cluster, including Google Container Engine (GKE).

<comment><USER4> Is there any documentation on how to enable this yet?

<comment><USER5> There isn't. While the underlying technology is available in GKE with 1.2, the ability to seamlessly launch a multi-zone cluster doesn't yet exist. As mentioned in other comments, you could reverse engineer the GCE setup scripts and do this manually if you really wanted to.

</comment></comment></comment></comment></comment><comment><AUTHOR> While the support in this release is fairly simple, it already unblocks _lots_ of use cases. Distributed "stateless" services should now be super simple to do in a multi-zone HA manner.

If you find that you're still not able to run your system multi-zone (e.g. because of the need to be attached to your PersistentVolume), the next releases (coming in just a "few" weeks time!) will keep building upon this. I'd encourage you to either send mail to the Product Manager (TheIronYuppie) or shout at Quinton during their SIG-Federation meetings.

Disclosure: I work at Google on Compute Engine (but Disclaimer: I don't actually work on Kubernetes).

</comment><comment><USER6> Are next steps for multi-zone support inclusive of these capabilities?

1) HA for master components 2) Multi-zone support for PersistentVolumes 3) Federated master components governing separate deployments

<comment><USER7> 1) HA for master components is actually supported already, albeit with some additional work required at cluster setup. See [http://kubernetes.io/docs/admin/high- availability/](http://kubernetes.io/docs/admin/high-availability/) . There's some ongoing work to automate that, but it's not at the top of our priority list, based on user feedback we've received.

2) It's not clear exactly what multi-zone support you're looking for w.r.t. persistent volumes. Right now pods with attached persistent volumes are scheduled into the zone where the volume exists. There is an undesirable limitation that it's not possible to create these volumes in zones other than where the master exists, and that's something near the top of our priority list to fix soon. Is there anything else you're looking for here?

3) It's not clear to me what you're asking here. Are you referring to federating multiple Kubernetes clusters together? In 1.3 we plan to release some aspects of that (multi-cluster GUI, multi-cluster command line tools, multi-cluster services etc).

</comment></comment><comment><USER6> Noting that the scheduling spread strategy is centrally configured using the SelectorSpreadPriority, can you override the scheduling behavior on a per service or pod basis?

<comment><USER8> It is a weighting function (not the sole strategy), so you can add additional weightings or constraints. For example, you can target nodes with specific labels which some people are using to target GPU nodes. What did you have in mind?

</comment></comment><comment><USER9> How does the configuration look like for a bare metal setup? E.g. spreading pods over multiple racks?

<comment><USER8> The functionality is driven by the labels on the nodes & volumes. So if your bare metal setup adds the same labels to the nodes & volumes, it will work identically.

We can apply these labels automatically on GCE & AWS (or any cloudprovider that implements the appropriate interface in the code), but on bare-metal this will rely on your provisioning infrastructure (which presumably understands your racks & datacenters). You can now pass custom labels to kubelet also, so this should be as easy as dealing with physical hardware ever is!</comment></comment>


Piratebay.org Now Being Used to Crowdsource "The Torrent Man" Film - <AUTHOR> https://torrentfreak.com/piratebay-org-now-being-used-to-crowdsource-the-torrent-man-film-200918/ <comment><USER2> Hollywood needs to do a movie on what happened to silk road back in the day (where Ross Ulbricht was imprisoned for life): [https://www.wired.com/2015/04/silk- road-1/](https://www.wired.com/2015/04/silk-road-1/)

That article alone has more drama than any recent thriller/drug movie... and it's mostly real life. An animated version in style with the article's cartoons would be amazing

<comment><USER3> It's already been made: [https://www.imdb.com/title/tt3312868/](https://www.imdb.com/title/tt3312868/)

<comment><USER4> Has anyone here seen it? Worth a watch?

<comment><USER5> If you already followed the story in the news then there's nothing new in this documentary. If you wanna learn about the story, its a good one.

Its narrated by Keanu Reeves. It has decent scores (~7-8 out of 10) on IMDB (already linked) and Rotten Tomatoes [1]

OP was asking about a Hollywood movie though; this is a documentary. A Hollywood movie would be to Snowden what this documentary is to Citizenfour.

[1] [https://www.rottentomatoes.com/m/deep_web](https://www.rottentomatoes.com/m/deep_web)

<comment> j-kent Fun fact: The director is Alex Winter who played Bill from Bill and Ted. I guess he got his buddy Ted to narrate.

</comment></comment></comment></comment></comment><comment><USER6> In a similar vein, there's also a crowdfunding campaign for the documentary 'Breaking Bitcoin'. It's to be about how Bitcoin was hijacked and throttled. [http://flipstarter.breakingbitcoinfilm.com/](http://flipstarter.breakingbitcoinfilm.com/)

<comment><USER7> please stop spreading FUD stuff... bitcoin wasn't hijacked and throttled. what happend was that some guy managed to brainwash some people and created bitcoin cash with that money

<comment><USER8> Then why do I have to wait so long for my Bitcoin BTC transactions to be processed?

<comment><USER9> You aren't paying enough to have it processed, is the technically correct answer.

<comment><USER10> Unless you want a transaction in less than 5 minutes (on average). If you want less than that, like say a few seconds for a credit card, then you have to use something besides bitcoin.</comment></comment></comment></comment></comment>


Features That Will Make Twitter Better - <AUTHOR> http://sixrevisions.com/web_design/10-features-that-will-make-twitter-better/

<comment><USER2> Couple nitpicks i have:

\- Re: #1, Strict categorization isn't always possible. You would have to deal with overlapping contacts (What if you work with someone who's also your friend/family member?). This makes it much less straightforward to handle and requires a much more complicated UI (How would you represent someone in both groups?)

\- It seems to focus completely on the web interface. A large majority of twitters traffic comes from its API. This means that if the author wanted to, he could make a client to do everything he wanted.</comment>


Programming in D – Tutorial and Reference - <AUTHOR> http://ddili.org/ders/d.en/

<comment><USER2> Serious question: are D and Rust trying to be the same thing?

I'm not asking whether or not their approaches are different, but whether or not they're trying to solve the same problem(s). I get the sense that this is the case; they're both trying to be a "safe C(++)".

<comment><USER3> IIRC D has a GC that you can opt-out of but in practice it's difficult to use its standard library when you do.

I'm just repeating a critique that I read, I haven't evaluated them against one another.

Having a GC excludes you from some programming domains -- well controlled latency, bootstrapping/operating systems.

<comment><USER4> The GC situation is getting better:

\- The language has the @nogc attribute to ensure at compile time that the GC is not used in a function or an entire module.

\- The number of standard library functions that have the @nogc attribute is increasing by the minute. :)

\- There is some effort to port Sociomantic's proprietary multi-threaded GC to D (theirs was written for D1).

</comment></comment></comment><comment><USER4> I am the author (of the book). AMA.

Ali

<comment><USER5> Why do you choose to write a book about dlang?

Can you give us us some godo area when dlang can be used?

Can we use dlang to build IOS/Android apps?

What is the advances of this language over go, python, java, ruby, rust?

<comment><USER6> Advantages compared to ...

Go: Generic type-safe highly efficient code. Can go lower-level like inline assembly. Can go higher-level because more meta programming.

Python: Faster. Static typing.

Ruby: See Python.

Java: Less boilerplate. More control over memory management. More meta programming. Natively compiled.

Rust: Easier. Garbage collection makes programming just as safe and is easier to use. Looks and feels more like C/C++/Java, if you already know them. More meta programming.

(of course, downsides of D are omitted ;)

<comment><USER7> Java is also native compiled. Language != Implementation.

OpenJDK is only the reference implementation. There are plenty of commercial implementations with AOT compilers.

Edit: did not write != properly

<comment><USER6> Yes, but it shows that the language was designed for interpretation. E.g. lazy static initializers is weird in AOT compilation.

<comment><USER7> It is not weird in functional programming languages.

<comment><USER6> I think you misunderstood me, because I used "lazy". It has nothing to do with Haskell lazyness.

In Java static fields are initialized when a class is loaded by the class loader. A class is only loaded when used. If anything (IO,scheduler,etc) changes the order in which classes are used, then initializers are called in a different order and their side effects as well. This semantic is mandatory by language definition.

In a Java AOT compiler this means every access to a static field must be prefixed with a (synchronized) check if the class is already initialized and optimizing it away is rarely possible. A JIT compiler does not even care, because it knows the class is already loaded.

For contrast, in C++ static fields are all initialized before main is called.

<comment><USER7> Actually I don't know how the current AOT compilers approach that situation.

Now with Oracle taking the steps to eventually make AOT compilation also a feature in the reference JDK, I suppose whatever issues might still exist they will be tackled.

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER8> What's the difference between D and C++? What's the difference between D and C#? What's the difference between D and rust? Who(which project or company) is using D? What's D is mainly designed for?

I like the syntax of D instead of rust, because it is much more like c++. The syntax of rust is weird to me.

</comment><comment><USER9> This might be a silly question: what is D used for? I "scanned" the site fairly quickly and didn't grasp the general application idea behind it.

<comment><USER6> Facebook has made a C-Preprocessor. D is great for such command line tooling. The standard library is not as extensive as Python's, but the situation is much better than in C-land. You can also use it as a scripting language.

D has a nice framework for servers (vibed.org), so you can write webservices (REST,JSON,etc). There is no great full-stack web framework like Rails or Django though.

GUI stuff works in theory, but I don't know any non-toy project. Games (OpenGL,SDL) are possible, but no serious project, yet.

Android/iOS does not really work, yet. Same with embedded, standalone, kernel stuff. ARM in general needs more work. For HPC it really depends on the use case (see dlangscience.github.io). Vector support and GPU integration is lacking. I don't know any image, video, or audio processing stuff in D.

<comment><USER10> Actually, that C Preprocessor was written by Walter Bright for DMC; just about every file has his copyright notice, and no Facebook copyright notice. I think they just translated it from C++ to D.

</comment></comment></comment><comment><USER11> what is D concurrency model ? does it have channels or classic threads ?

<comment><USER6> D is not really opinionated about concurrency and parallelism. It provides access to the OS mechanisms (pthreads). The standard library also has some task-based stuff. Then there are fibers (user-level threads), which vibed.org makes convenient to use. There is no definitive channel/queue mechanism provided by the standard library so far, but people have implemented them in libraries.

tl;dr: With D you use whatever is best for you.</comment></comment>


Ask HN: Who's blogging and what platform do you use - <AUTHOR> User eitland wrote: > I wish we could have a thread (possibly even a monthly thread here, like who is hiring) where people could mention their blogs, web sites etc. <comment><AUTHOR> I have two blogs [0][1]. For my main blog I use a Perl script that's far from ready for public release. For the tumblelog [1] I wrote a static site generator [2] that's available via GitHub

On the main blog I write about technical stuff, and solutions. The tumblelog is mostly links to interesting things I've read on the Internet with now and then short book reviews and some photos I have taken.

[0] [http://johnbokma.com/blog/](http://johnbokma.com/blog/)

[1] [http://plurrrr.com/](http://plurrrr.com/)

[2] [https://github.com/john-bokma/tumblelog](https://github.com/john- bokma/tumblelog)

<comment><USER2> Have linked to your sites from my site. Exactly the kind of content I want to read and link to :-)

<comment><AUTHOR> Thank you!

</comment></comment></comment><comment><USER2> Sorry I didn't see it in time, maybe we can try again around next monthly who's hiring?

<comment><AUTHOR> Good plan, I think it's a solid idea.</comment></comment>


[Ask HN] IBM has served a DMCA notice to the GPLed repo of the OpenLava Project - <AUTHOR> OpenLava is a workload manager, which means that if you have N computers and M scientists, it will decide what program will run in which computer and when.
OpenLava is a GPL'ed version of Platform LSF 4.5, under the GPL2. It was forked by Platform LSF as an agreement with Redhat in 2007, before IBM bought Platform LSF.
According to the project leader, David Bigagli, IBM has decided to target the project by submitting a DMCA notice for the current version of the program on Github (https://github.com/openlava) and now asks that the website hosted on AWS be shut down.
What can these guys do?
https://groups.google.com/forum/#!topic/openlava-users/z4V4oF1tfdY
Update: apparently, on Reddit, there is the guy that was directly involved in the process of releasing some of the Platform LSF parts as GPL:
https://www.reddit.com/r/linux/comments/5j3mn2/ibm_is_trying_to_bully_the_openlava_project_a/dbd5ipp/ <comment><USER2> They could file a DMCA counter-claim (claiming that they are the legal copyright holder), at which point IBM would need to take legal action to get the DMCA takedown reinstated.

But to be really sure that IBM doesn't have any claim to this version of the software, they should first consult an intellectual property lawyer. They could contact the EFF to see if they'd be willing to offer free legal representation.

<comment><USER3> One redditor commented on this. He said it requires a consent to US court jurisdiction, which his lawyers said would bring other issues, if you are not a US resident or citizen.

[https://www.reddit.com/r/linux/comments/5j3mn2/ibm_is_trying...](https://www.reddit.com/r/linux/comments/5j3mn2/ibm_is_trying_to_bully_the_openlava_project_a/dbd7u10/)

</comment></comment><comment><USER4> Clickable: [https://groups.google.com/forum/#!topic/openlava- users/z4V4o...](https://groups.google.com/forum/#!topic/openlava- users/z4V4oF1tfdY)

</comment><comment><USER5> Please consider reformatting this post as an [Ask HN] and without the (as I read it) accusatory tone.

I say this in the interest of raising awareness of what may be happening here.

<comment><AUTHOR> Done.

</comment></comment><comment><USER3> Why is this news in December? The announcement of the take down notice seems to have been on November 1st.

It is important, but the titles suggest the take down happened today.

From what I can tell the only change is that a Fedora maintainer has claimed he was involved in the fork and IBM has no right to DMCA this. This seems to have happened after OP posted according to the update.</comment>


Getting Things Done: Startup Tips - <AUTHOR> http://zvin.is/get-things-done-startup-tips/?utm_campaign=website&utm_source=sendgrid.com&utm_medium=email

<comment><USER2> Has anyone used OmniFocus 2 yet? I want to get my hands on it.</comment>


Anti Mediocracy Manifesto for Software Development - <AUTHOR> http://gabordemooij.com/index.php?p=/manifest <comment><USER2> While very idealistic and beautiful in a way as all manifests tend to be, we (along the author) tend to forget certain truths - the middle of the gaussian curve is fattest; all natural distributions follow that curve, and developers are no exception. Most of us, by definition, are mediocre. There's nothing that can be done about it. We should not shun, but rather embrace that. Not by deluding ourselves that if we follow some idealistic manifesto we somehow rise above our limited skills and minds. We will not. We will suck. Our tech will suck. Other peoples' tech will suck. There is no ideal that can be attained. This is not the profession of saints and Buddhas. But by knowing this, by accepting this, we can start working on raising the standard for mediocracy...

<comment><USER3> But surely the purpose of the manifesto is to skew that curve to the right.

<comment><USER2> One might as well try to skew global IQ stats to the right. And please, don't call me shirley.

<comment><USER4> This has been happening over the last 100 years. That's why IQ tests need periodically recalibrated.

<comment><USER2> thing is, the curve remains the same. Fat in the middle.

<comment><USER5> Of course the curve will remain centered about 100, because that's how IQ is defined.

</comment></comment></comment></comment></comment></comment><comment><USER6> These lines sound like a recipe for scope/feature creep and never ending development process.

>Never do requirement analysis. Never write technical requirements or functional ones. If you do, you have already failed.

In that case, how do you know when the software is finished and your contract has been fulfilled?

>Creative solutions are often holistic in nature, driven by first-hand experience, discussion, interaction and... thinking. If you want a developer to write a great piece of code, let him or her scratch the itch you're trying to scratch.

So, you do all your thinking, without capturing anything, and then the software is finished when the developer is bored?

<comment><USER7> you missed the point: The point is, if the requirements for a piece of code are so complex that you NEED to write a requirement analysis, that you NEED to do anything other than plan out your code, and write it, than your software is already too complicated. You need to narrow the scope. Lots of small systems is better than one large system.

<comment><USER8> Yeah, sorry, but real life software doesn't work that way. Real life software is often inherently complex.

<comment><USER7> I disagree. Complexity can arise through interactions between simple pieces of software. Given, planning that out may be complex, but certainly less complex than writing it all in one go.

<comment><USER8> And I disagree right back at you :)

All you're doing is shifting complexity around. Don't want one big piece of complex software? Fine. Break it up - now you have a bunch of simple pieces of software that all need to work together in a complex manner. You still need to plan for how all that works, and that often requires complex requirements.

It's not "certainly less complex". The total complexity of the system is still the same.

<comment><USER7> And I... Kind of agree? :).

You do have to plan out your software, I guess I kind of de ied that. I was wrong. You were right. Take your victory dance, then sit down, I'm not quite done yet.

>It's not "certainly less complex". The total complexity of the system is still the same.

The total complexity of the system is the same, yes, but the GLOBAL complexity of the system is significantly reduced: A lot of complexity is isolated, and if the components interact through well-defined interfaces, you can treat each as a black box (theoretically, once they work), and use them as building blocks to build your system. Every programming paradigm, language, and system in the last 60+ years is based around this idea, from structural, to OO, to Unix, to Lisp, to Microservices, and on to the next craze.

So, I assume that this something you agree with. In which case, congrats, you've convinced me.

<comment><USER9> How is it reduced if you have everything needing to communicate back and forward? Sounds like more complexity to me.

<comment><USER7> The components aren't necessarily separate apps, but even if they are, that problem has been solved many times over. Take your pick: HTTP, raw sockets (TCP or unix domain), ZeroMQ, RabbitMQ for larger projects, Shared Memory, pipe(2) (and friends), hell, even message queues and semaphores, if you hate yourself...

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER10> > ... it's not about gobbling together the right tools and do some plumbing to > make it work. No, it's using tools to craft a work of art. Anyone not > recognizing this is an inferior software developer by definition ...

So — if you don't prioritize your ego and personal sense of artistry over accomplishing the task, you are an inferior developer? I would never want a person like this on my team.

<comment><USER11> I mean, I guess that's one way to interpret what he's saying... I interpret it as "have an eye for design and creativity to solve your problems, don't just be mindless and glue together frameworks and libraries". I personally think this is compatible with working on a team.

I've far too often seen code that does look like it's just a bunch of libraries glued together and if you really teased it apart you'd end up with something that's a lot less code and a lot fewer dependencies. And I definitely know people who wouldn't think twice about just adding another dependency to a codebase just so they could use one function. Sometimes that's justified, sometimes it's the result of lazy thinking.

</comment></comment><comment><USER12> I'll never understand comparing code to art. Not the first time I'm seeing it but for me it couldn't be further apart.

There is no best way to make a drawing. There is no best way to make a movie. There is no best way to tell a story. There is no best way to make a painting. There is no best way to create a song. ... There is (almost?) always a best way to do a piece of code. Code has nothing to do with emotions. I'm not trolling I truly don't get it, like at all.

<comment><USER13> This is a dubious assertion. Best is fundamentally a subjective metric. Code is only the best for a given set of criteria. What's best code for rapid development isn't best for maintainability. Sometimes you have to break maintainability for speed bottlenecks. Saying there's a best way to code something is a very contextual claim.

</comment></comment><comment><USER14> I don't mean to be purely negative but this is so wrong as to be harmful. My one solace is that my marketplace competition may read this and thereby make themselves less effective pursuing some silly ideal of purity while I'm busy getting shit done.

<comment><USER15> Absolutely.

This looks to me like a developer who is frustrated that nobody listens to him, who wrote a manifesto saying that everyone should do things in the way that HE thinks they should be done. Reading through the manifesto, it is obvious to me why nobody is listening to said developer.

</comment></comment><comment> keithb- This is fantastic; the perfect example of tilting at windmills. So, I'll take up the role of Sancho.

Using tools to craft a work of art? I'm sure some projects deserve our collective accolades, but no one should consider them art. The only projects that should end up in a museum are those that are no longer in use.

Risk of bugs increases with each piece of code? I'm sure this is impossible. The risk is already 100%: there will be bugs. They only increase in volume.

Always be wary of fancy websites? I'm sure the rant preceding this nugget has a point (e.g. maybe "never compromise on code quality), but let's be honest: a fancy website is a work of art, See #1.

Withstood the tooth of time? I'm sure these mixed metaphors are meant to be poetic, but when you lead with a statement followed by an exception, then your whiskey spigot can engender an acreage of Hidalgo.

</comment><comment><USER16> Software Engineering is an exercise in compromise. How does the risk of a bug compare with the benefits of the code?

I think it's fair to say that there is more code being written today, by a more diverse group of people, than ever before. It would be a real shame to tell them the amount of code they should be writing is 0 since that's the only way to prevent bugs.

</comment><comment><USER17> Lost me here:

"Therefore, our true purpose is to express the intentions of our clients using as little code as reasonably possible, accompanied with lots of documentation and lots of tests (testing code and unit tests don't count as LOC). We should distrust every line of code written by ourselves as well as those written by others. The best code has 0 lines. Because in zero lines of code, there is room for exactly zero bugs."

Less code does not necessarily mean less bugs.

<comment><USER18> Less code does absolutely mean less bugs, _in the majority of cases_. Of course it is not an absolute rule and can be gamed, but simple logic dictates that since it is not possible to always write 100% bug free code, the more code one writes, the more chance there is to introduce bugs.

However I don't believe the statement was meant to be taken entirely literally.

<comment><USER17> Then why do I spend so much time fixing bugs in code where the concept was complicated to the nth degree so it could be written in five lines instead of ten?

I agree that fewer lines of code is better, unfortunately if you hold that concept in too high a regard it's easy to make a mess. Some programming challenges are complex and the complexity can't be avoided. Sometimes solving that problem in fewer lines of code makes the problem even more complex. Just because the complexity is moving from the code itself into the developers head doesn't NECESSARILY mean that it will be less prone to bugs.

<comment><USER19> Those 5 lines probably had 100s if not thousands of lines backing them. Maybe best to say 'fewer lines of code executed' as it doesn't really matter whether those lines are in a library or in your project, they still have a chance for bugs.

<comment><USER17> You're missing the point, it's not about executed code it's about concepts and simplicity.

Sometimes people work too hard to make two functions with slightly different objectives into a single complicated function. This can save lines of code since you aren't writing two similar functions. In general this is good practice but it's VERY common to take this too far, and it's very likely that the resulting complicated function will be MORE prone to bugs than the two simpler functions would have been.

</comment></comment></comment></comment></comment><comment><USER20> "It does not matter how many people use framework X."

Unfortunately, it does. It sort of makes sense Manifest Against Mediocracy includes such statement, since this is the large impediment in fight against mediocracy, but simply asserting it doesn't make it true.

<comment><USER21> It was not simply asserted. It was supported with an example of a security problem that would be experienced by everyone using a framework. We've seen it in reality, with the left-pad fiasco.

<comment><USER22> This really was a fiasco.

We went from big frameworks to a bunch of libs.

Many people got into extreme and even used stuff like left-pad.

I try to only include third party software for stuff I don't have the time or skills to implement. This makes my utils directory a bit bigger, but that's it.

</comment></comment></comment><comment><USER23> I really think you mean "mediocrity" or "the quality or state of being mediocre" rather than "mediocracy" or "a dominant class consisting of mediocre people, or a system in which mediocrity is rewarded."

I say this because you're trying to "give developers a code to live by that will increase the quality of code and coders." However, you're not talking about a "dominant class" or a "reward system." So I think the word choice is off.

</comment><comment><USER24> I personally don't think this is the correct way of looking at this situation.

Good code as it stands is code that produces an application that fulfills the requirements without breaking until someone naturally thinks to replace it. If you can achieve that you can achieve something better then most "good code" I've seen in my lifetime.

Good code is something that isn't obtrusive to the end user (the most important user of the code).

I don't know of another way of putting this but "easy to maintain" code is a different thing. Some small piece of software could have been messily globed together and thrown into production. This piece of software could have been running for 15 years+. I still think that's good code, but it is not inherently "easy to maintain."

We shouldn't be striving for 1 goal, we have two that are close to similarly important. We have maintainability by a programmer, and you have ease of use from the client.

To make the small fraction of people who are software devs live's better, we focus on "easy to maintain' code. To make everyone's life better we need to focus on that and making functionally sufficient code.

Very few projects I've seen do both. They either aim to be 100% clean code while sacrificing features that greatly improve UX or either 100% functional while being globed together unorganized messes.

I think we need to think of good code as a project that fulfills it's entire reason for existence while being documented and maintainable (on both the UX and maintaining side of things).

</comment><comment><USER25> Nonsense and wisdom are so well balanced in this piece that I can't decide whether this is a joke or not.

</comment><comment><USER7> This is either brilliant, or excellent satire. Which one it is depends on how you define the terms. There is good advice here, but if you take it literally, and don't pay attention to context, and use common sense, you'll end up with some really bad advice.

</comment><comment><USER26> > Anyone not recognizing this is an inferior software developer...

No True Scotsman at its finest.

<comment><USER27> We can all agree that real programmers don't eat quiche though, right?

</comment></comment><comment><USER28> Personally, I would have gone further.

Somehow people forgot the old Ethos of being a programmer working on slow machines that had only 8k of ram or so. This would train humility, the art of writing small and efficient code, etc.

Now kids implement factories all over the place when they are not needed (amongst other patterns), it's a pattern galore really. As if they used fancy data structures regardless if they are needed or not just to float their ego; reassuring themselves that they do know tons of stuff.

ah well... Sorry for that rant :)

</comment><comment><USER29> Some of you seem to be missing the satire here.

<comment><USER30> "Any sufficiently advanced satire is indistinguishable from magic" or something.

It's certainly brightened up my Wednesday reading the comments on here.

</comment></comment><comment><USER31> I could write a toughtful response to that... but given the quality of the original, this will suffice:

Eight

Be skeptical to any advice from a developer that is not old enough to have grown some white hair. If the advicer is male, gray beard preempts other white hair.

Nine

Be actively hostile to any advice by male developers that ar not old enough to have grown a beard at all.

</comment><comment><USER32> A manifest against mediocracy in software developer by a PHP developer. Start with dropping PHP. SCNR

</comment><comment><USER33> There is a typo in the link. The corrected link has a 'o' added to the end, as in:

[http://gabordemooij.com/index.php?p=/manifesto](http://gabordemooij.com/index.php?p=/manifesto)

</comment><comment><USER34> php developer talking about "It does not matter how many people use framework X." and "Never do requirement analysis. Never write technical requirements or functional ones. If you do, you have already failed."

Trolling at its finest.

</comment><comment><USER35> I stopped reading 14 words in because gobbling != globbing.

For that matter, manifest != manifesto.

Probably English isn't the author's first language. I should forgive him and carry on, but a quick scroll reveals the words idiot and whiskey. TL;DR

<comment><USER23> ...and mediocrity != mediocracy.

<comment><USER36> Corrections to the article have been made, and it is now at [http://gabordemooij.com/index.php?p=/manifesto](http://gabordemooij.com/index.php?p=/manifesto)

The power of peer review!

<comment><USER35> Nice. Peer review continues: wortless.

Uh, I kinda like the tone, but this guy might not be familiar with the decades of math and engineering that back something like Haskell.

It's true, there's an art to writing software, but...

Tools (practices, ideas) that have been honed and refined to the point that they are reflections of physics and logic aren't to be dismissed.

Those tools are to be wielded by artists!

</comment></comment></comment></comment><comment><USER37> Mediocracy or mediocrity?

<comment><USER38> I think he refers to the tyranny of popularity-based development.

</comment></comment><comment><USER39> "The best code has 0 lines. Because in zero lines of code, there is room for exactly zero bugs."

Does failing the acceptance tests count as a "bug"?

</comment><comment><USER40> I picture him glowing with a strong sense of superiority while sitting in his bedroom in his parents' house writing this.

</comment><comment><USER41> Is the proper term "Manifesto"? A Manifest is a list of things included in something, like a bill of lading.

<comment><USER42> [http://bfy.tw/6w16](http://bfy.tw/6w16)

</comment></comment><comment><USER43> In part Five: '...If it's init system is systemd, oh well...'. what's wrong with systemd?

</comment><comment><USER8> This reads like it was written by someone without much experience in building real-life, large-scale systems.

</comment><comment><USER44> > No, it's using tools to craft a work of art.

Stopped reading right there

<comment><USER45> Then you did yourself a disservice, and now have trumpeted your laziness and ignorance.

</comment></comment><comment><USER38> Magnificent, where do i sign?

</comment><comment><USER46> Ctrl+F "customer" -> zero results

Did we forget a little detail here?

<comment><USER47> The term "client" is being used (once):

> Therefore, our true purpose is to express the intentions of our clients > using as little code as reasonably possible, accompanied with lots of > documentation and lots of tests (testing code and unit tests don't count as > LOC).</comment></comment>


Did 'Richard II' Provoke an Elizabethan Rebellion? - <AUTHOR> https://slate.com/culture/2018/06/how-shakespeare-may-have-played-a-part-in-an-uprising-against-queen-elizabeth.html <comment><USER2> Fascinating...I have little doubt this was part of the impetus behind _Ruled Britainnia_, a Turtledove alt-history in which the Second Spanish Armada successfully invaded England, and the story is told from Shakespeare's perspective as the main character involved in the interactions of new plays of his and the brewing political unrest.

It's one of my favorite books, if only because much of the conversation is allegedly in free verse and I end up unable to speak correctly for 10-30 mins after a good reading session.

</comment><comment><USER3> That was incredible in that it mentioned everyone but the person that links them all together... Edward de Vere.

<comment><USER4> Oxford had nothing to do with _Richard II_ and very little to do with the Essex rebellion. He was on the jury that condemned Essex and Southampton, along with many other noblemen. He had also tried and failed to get Southampton to marry his daughter years earlier. Otherwise, his only involvement in court politics at that time was the occasional letter to Robert Cecil asking for various forms of aid (with no apparent success).</comment></comment>


Does the new PHP 7 will be able to run real time communication? - <AUTHOR>

On stack overflow they always says that PHP is not a good programming language for real time applications in this case like real time chats, long polling, comet, etc. with PHP 7 would this change? or I need to start learning node.js? <comment><USER2> It already does that: Event-driven, non-blocking I/O

[http://reactphp.org](http://reactphp.org) [http://daemon.io](http://daemon.io) [http://socketo.me](http://socketo.me) (based on reactphp)

<comment><AUTHOR> Thank you attozk I didn't know about this.</comment></comment>


'Me love you long time' recruiter told Asian-American female jobseeker in email - <AUTHOR> https://www.usatoday.com/story/news/nation/2019/07/01/chicago-search-vp-told-asian-woman-jobseeker-love-you-long-time/1619777001/ <comment><USER2> Why is one person's nonsense immature antics actually news? Just fire them and move on.</comment>


10 FREE TICKETS to Hackathon this Saturday in London, UK - <AUTHOR> http://cbyt.es/Rmabz6
Value £65.00 - First come, first serve. The secret access code is SUSH1. <comment><AUTHOR> Secret Code is SUSH1.

</comment><comment><USER2> Thanks.</comment>


Scaling Twitter: Making Twitter 100x Faster - <AUTHOR> http://highscalability.com/scaling-twitter-making-twitter-10000-percent-faster <comment><USER2> "1 MySQL Server (one big 8 core box) and 1 slave. Slave is read only for statistics and reporting."

is twitter really running on only one mysql server, or is this information outdated? no sharding, nothing?

<comment><USER3> I think this is outdated. It says 250k users. If aplusk has over a million followers this number can not be correct.

<comment><AUTHOR> This is a pre-Oprah article.

</comment></comment></comment><comment><USER4> Twitter is a really simple application to scale. The fact that it took Twitter so long to get it somewhat right is remarkable, but I'm not sure I'd be so keen to look at them as an example of how to design scalable architectures.

<comment><AUTHOR> Well, the article explains that their mistake was that they tried to use external software for monitoring and scaling instead of their own, and they switched numerous times because they _almost_ worked, but not quite, until they built their own.

</comment></comment><comment><USER5> This article is two years old.</comment>


Black discards piece after piece for positional advantage - <AUTHOR> http://www.chessgames.com/perl/chessgame?gid=1228673 <comment><USER2> White's moves #10 and #11 make no sense to me.

Move 10: he could have taken the advanced bishop with a pawn and that rook would have still been up for grabs in step 11.

Move 11: again he could have taken the bishop, this time with his own bishop, instead he opts to move it out of the way. Why on earth?

Perhaps he was just baffled by his opponent's apparent total disregard for losing pieces?

<comment><USER3> When black's bishop takes the knight, I don't think white could've done anything to escape the mate.</comment></comment>


We Should Abolish Silicon Valley - <AUTHOR> https://www.vice.com/en_us/article/g5xzq9/why-we-should-abolish-silicon-valley <comment><USER2> This is a garbage take</comment>


Bringing functional to the frontend – Clojure and ClojureScript for the web - <AUTHOR> http://blog.getprismatic.com/blog/2013/1/14/bringing-functional-to-the-frontend-clojure-clojurescript-for-the-web <comment><USER5> If you're interested in a functional approach to UI code, check out functional reactive programming (FRP). It's a declarative way to specify UI logic which abstracts away much of the inherent messiness of using mutable state and callbacks.

I've played around with FRP in Haskell, and have found it much nicer than the more standard approaches to implementing UI logic. Before using FRP, my main UI experience was with Java Swing and web development, and FRP is definitely a step up. I've found it easier to write the code in the first place and then _much_ easier to add new features and logic.

I've only used FRP with native UIs, but I think it would be very natural for web development as well. It's certainly a shift in philosophy and mindset, but one that I think is well worth overcoming.

Unfortunately, I do not know of a good tutorial for using FRP. I'm sure there are some out there, but I basically picked it up by reading academic papers which are not to everyone's taste. That said, I actually found some of the papers were clearer than the blog posts and SO questions I found online!

I'm probably going to write a basic FRP tutorial in Haskell some time soon, probably built around some very simple application (maybe John Conway's Game of Life). It really is a fun subject. Is anybody interested in something like that?

<comment><USER6> I recently finally understood FRP and I'm working on my own library on top of Flapjax and Enfocus (ClojureScript) to make things simpler than doing everything by hand.

However, I can't find examples of systems of moderate (or big) size - <USER2> to get inspiration from, all examples I've seen are quite small and do too much by hand. They often select elements (like button to track click on) from whole document by id (and in big app this is pretty useless except for some top-level elements), or interwind templates with bindings to events and interaction between them is structured so that it feels like almost using globals. Directly changing top-level data from some inner template.

Anyway, I've got some ideas - display is easy though, what's hard is nicely structuring forms and buttons IMO - but it takes time to carve them out in code. I would love to read something on topic of structuring applications, which are more than a single input and a single list.

</comment></comment><comment><USER7> We use ClojureScript (and Clojure) at <http://economi.co> and I'm really enjoying it.

Maybe one of the most difficult things coming into it is trying to relate it to something like BackBone.

However generally speaking in Clojure the culture is more about libraries than frameworks.

C2 <http://keminglabs.com/c2/> which on the outset looks just like a ClojureScript version of d3 is actually a great library to use instead of a traditional front end framework.

Check the example implementation of the class TodoMVC list here: <https://github.com/lynaghk/todoFRP/tree/master/todo/c2>

It's uses normal Clojure data structures within atoms as the data model ([https://github.com/lynaghk/todoFRP/blob/master/todo/c2/src/c...](https://github.com/lynaghk/todoFRP/blob/master/todo/c2/src/cljs/todo/core.cljs#L9)) and uses C2 to automatically update the UI ([https://github.com/lynaghk/todoFRP/blob/master/todo/c2/src/c...](https://github.com/lynaghk/todoFRP/blob/master/todo/c2/src/cljs/todo/list.cljs)). Very elegant.

I'm just starting to explore this area myself, but have already found it useful for a few smaller parts of our site.

<comment><USER8> Don't worry about how anything compares to frameworks, because they don't matter anymore.

We think traditional frontend frameworks - whether of the rails/django variety or the backbone variety, are generally rubbish in a nearly infinite number of ways. It's a style of programming based on wrapping weak mutation oriented idioms behind monolithic APIs and design patterns. We think default functional style and fine grained composability is the future, and mutation + oo design patterns + frameworks is the past.

<comment><USER9> It may be the future for very skilled developers that have already familiarised themselves with frameworks and design patterns and are capable of moving past them. The majority of software developers benefit enormously from the conventions encouraged in a framework like Rails. If Clojure is going to be adopted widely (if that is a goal of the project at all), the community needs to work on better communicating best practices to make up for the lack of framework 'guidance'.

<comment><USER10> Eh, even the least charitable would have to admit that frameworks enforce style. On a large project, this matters hugely. I don't care how good your devs are they DO have different opinions re: style.

<comment><USER11> I disagree -- frameworks enforce structure (especially of callbacks), not code style.

Unity of code style is something you can solve with standards, style guides, pairing with new developers, and following conventions from surrounding code.

Clojure is nice because the community, while having different opinions about how often you should use X technique vs Y, generally has core sensibilities about what makes for good, simple code that composes well and doesn't tangle concerns. (This is largely due to the influence of Rich Hickey.) This (and not "perfectly uniform code style") makes for an effective large team.

</comment></comment></comment></comment></comment><comment><USER12> If you're interested in learning more about Clojure and ClojureScript, check out the upcoming Clojure/West conference in Portland, OR March 18-20th (<http://clojurewest.org/schedule>), including a keynote from Rich Hickey, creator of Clojure. There is also a 1 day training class the day before on ClojureScript if you want the deep dive (<http://clojurewest.org/training>). Register here: <http://regonline.com/clojurewest2013>

<comment><USER8> Highly recommended! Alex's events are always great - long on technical and short on BS!

</comment></comment><comment><USER13> Great article. I have spent a fair amount of time playing with ClojureScript, read "ClojureScript: Up and Running" and a lot of tutorial material on the web, and used it a bit in a customer project.

That said, ClojureScript has not really _clicked_ for me yet, but this article and the pointer to dommy is getting me closer to adopting ClojureScript.

I use Clojure + Compojure (and still Noir) + Hiccup for just about all of my web app development. Love Hiccup. Having (mostly) Hiccup on the client side with dommy looks very cool.

<comment><AUTHOR> I'd be curious to hear what you're not liking about it.

<comment><USER13> It is not that I don't like it, I just tend to be a little slow in adopting new stuff into my set of _almost_ _always_ _used_ _tools_.

</comment></comment></comment><comment><USER14> So guys, I hate to bring this up in an unrelated topic, but when are you going to open-source Graph? It has been 4 months since you said "soon" and I'm squirming in anticipation.

</comment><comment><USER15> On server-side templating - did you consider a selector-based approach like cgrand's Enlive?

As I see it, it brings the best of both worlds (the comprehensibility of "logicful" templating, the maintainability of strictly separating presentation and data transformations)

<comment><AUTHOR> No, but I think enlive is great.

To me and the team, most of our functions are making Clojure data structures and thinking of templating as converting data to dom elements or HTML strings seems the most compatible with that way of thinking. But both are definitely valid.

</comment></comment><comment><USER16> "The above is valid Clojure code, not another language whose syntax you have to learn or separate compiler to use."

Even though this is a fair point, the comparison between the Jade solution and the Clojure one is invalid. Jade was conceived as a whitespace-significant language. Its biggest benefit over plain HTML (or HTML-based template engines like Moustache) is the usage of indentation to determine hierarchies.

The comparison would be more valid with something like <http://domo-js.com>, which is solving the exact same problem: using a single language (JS) for markup production – and even replacing CSS.

<comment><AUTHOR> That's a fair point. Really, I think we're making the argument that we prefer data approach to templates (i.e., language-native data structures (maps, arrays, strings)) represent html structure.

You can certainly take that approach in JS. domo-js isn't quite that, it would look more like:

["html" ["head" ["title" {class: "class1"} "Welcome to Domo"]]]

As we say in the post, you can totally pull all this off in JS, but I think if you're going to be manipulating nested data structures, it's better to have immutable data structures built in and the suite of functions that can manipulate them. Clojure makes building template structures really easy: persistent data structures, map/seq argument destructuring, keywords, sets, etc.

</comment></comment><comment><USER17> I really love Clojure, but it still feels a bit heavy-weight for anything but numerical computation. However, I'd ignore that if the performance gains were significant. What are the performance advantages of ClojureScript server-side templating compared to client-side Javascript templating? The vogue style these days seems to be a one-page app where the clicks take barely any time, because the jQuery/Zeppo/Underscore selectors are all cached.

<comment><AUTHOR> While you can use ClojureScript (CLJS) server-side running on say node.js, the largest benefit is as a replacement for client-side JS (ClojureScript converts to JS at compile-time).

You can actually use all the libraries you mentioned (jQuery, underscore) from ClojureScript. What CLJS really brings to the table are a set of abstractions and data structures that make it easier to write strong reusable functional code. In fact, alot of underscore comes built into CLJS and I think much of what jQuery buys you can be handled as a good CLJS library (but more on that soon!)

<comment><USER17> The idea of decomposing jQuery into small libraries Clojure-style is very appealing. The advantage would be building the specific Javascript file needed by the client at request time, and caching intelligently to prevent doing this too much. The extra benefit would be, you could break out the pieces of jQuery devoted to patching cross-browser issues, and only include the ones you really cared about.

Very cool!

<comment><AUTHOR> Yeah absolutely. One of the better CLJS features is getting the Google Closure modules and explicit dependencies.

We'll probably add dom selectors and/or manipulation and wheter it's the same library as dommy (github.com/prismatic/dommy) or a different one will depend on if the selectors borrow the same abstractions and syntax as templating.

</comment></comment></comment></comment><comment><USER18> I'm using my ported version of Hiccup [1] to ClojureScript for a while now and share most of my templates between Clojure on the server, and ClojureScript on the client side with good sucess. It can sometimes get a little bit hairy to share code between the 2 platforms, but I hope something like Common Lisp's feature expressions [2] will make it into Clojure and ClojureScript soon. When this arrives, life will be a lot better ...

Just for fun, I benchmarked my Hiccup port against the other candidates.

Compilation Mode: Whitespace {:crate 7.076333333333333, :jquery 1.4643333333333333, :dommy 2.1186666666666665, :hiccup-str 1.985, :hiccup-node 2.3476666666666666}

Running Hiccup and Dommy in advanced mode get's the time towards unoptimized jQuery.

Compilation Mode: Advanced (Crate and jQuery don't run in advanced mode) {:dommy 1.3436666666666666, :hiccup-str 1.0293333333333334, :hiccup-node 1.3506666666666665}

One thing to note: The original Prismatic tests were building jQuery Nodes and appended them to an UL element. Building strings and appending those to the node speeds the whole thing up a little bit further [3]. In the above benchmark :hiccup-node uses DOM nodes to append to the root, :hiccup-str uses Javascript strings.

I can only agree. Using a Hiccup like template system in Clojure is very nice.

[1] <https://github.com/r0man/hiccup/tree/clojurescript> [2] <http://dev.clojure.org/display/design/Feature+Expressions> [3] <https://github.com/r0man/dommy/tree/hiccup>

</comment><comment><AUTHOR> Author here. Happy to answer any questions or comments.

<comment><USER19> I've been using Clojure for a while now. Do you have any particular recommendations for resources for getting started with ClojureScript? I tried a while back and got really confused.

<comment><USER20> I haven't used it but here's a 10-part mega tutorial on modern Clojurescript: <https://github.com/magomimmo/modern-cljs/>

</comment></comment></comment><comment><USER21> I agree that using data as templete is great. This is a typical example of "The value of value"(Rich Hickey's speech).

And I think client side have a bit different requirement compared to server side. At client side, I often need to manipulate specific element instead of root element which crate and dommy return. So I forked crate in order to get a collection of created elements as a hashmap. <https://github.com/hozumi/crate- bind> This is useful. I will create dommy version of this.

</comment><comment><USER22> the dom is a mutable data structure and the native (fast) dom apis expose mutable interfaces. so dynamic sites (you know, single page html5 apps doing all sorts of client-side dom manipulation) are either going to be slow, or are going to have an imperative core, which is where you need functional programming the most ;(

maybe HTML6 will have native functional dom manipulation and we can rewrite all our favorite javascript libraries to expose functional interfaces. one can dream.

<comment><USER15> I'm afraid you're confusing data structures (such as vectors, sets and maps) with the document model object.

Not even in JS the DOM and objects are the same - some properties of the DOM have 'magical behavior' attached.

ClojureScript does not provide any functional interface to the DOM - <USER3> would involve a Haskell-like model of programming (monads etc), which Clojure programmers rarely do in practice.

<comment><USER22> i don't think i'm confusing anything. Clojure programmers love their persistent data structures, and in a browser environment, the most important data structure - the document model object - is not persistent and cannot be made persistent in a performant manner because it is a native api.

there is ongoing research into dom manipulaton in clojurescript - <USER4> Barski presented one approach[1] at Conj 2012 where the dom is mirrored in clojurescript data structures, and then 'synced' with the dom - so that way the imperative ickyness is tucked away in the sync method - it remains to be seen if that can be made fast enough until we get a native persistent interface to the dom.

[1] <https://github.com/drcode/webfui>

<comment><USER15> Characterizing side-effects as a series of supposedly functional transformations doesn't sound quite alright to me.

That said I'm curious about such an approach.

<comment><USER22> Modeling side effects as transformations on data is what functional programmers do all day. I'm not talking about monads - simple things like inserting keys into a map and manipulating collections does not rely on side effects in functional languages.

</comment></comment></comment></comment></comment><comment><USER23> Another option for functional on the front end (and back end) is LiveScript. <http://livescript.net/> Many people may not have heard of LiveScript.

I prefer LiveScript for a number of reasons, starting with the fact that I just don't like brackets and parentheses enough to want to use them everywhere.

</comment><comment><USER24> My biggest problem with ClojureScript is that is very hard to reason about code written in it if you are a beginner.

<comment><AUTHOR> It's definitely a complicated language to learn since you have to learn the complexity of

(1) Clojure core itself and readjust to functional programming (2) Understand how ClojureScript is translated into JS in order to do interop which will absolutely be necessary for any real project (3) Understand Clojure on the JVM in order to understand/write macros

</comment></comment><comment><USER25> Semi-related question but...

One of the thing that I love when developing under Emacs is that I can get real-time validation of my XML (eg XHTML) based on, say Relax NG. This even works nicely with multiple-major-mode (eg I can get realtime validation of the XML part, yet see JavaScript as JavaScript inside the same source file).

Now my question: with all these templating libraries like Jade, aren't you losing feature like real-time validation?

And when such a templating library comes out, it means every editor out there as to be modified so that it supports it?

Or is there some kind of a schema that can be used to perform real-time validation + auto-completion?

My point is: I definitely see the point as replacing Jade by Clojure because you can then manipulate your templates as data, which is gorgeous. But I don't see the point of using Jade in the first place...

<comment><AUTHOR> The nice thing about dommy (github.com/prismatic/dommy) is that emacs doesn't need to be changed at all to use it. It's just clojure and all the highlighting and the emacs major mode work.

Also out of the box, you get a repl to live test and evaluate template functions and data structure. It would only take a few lines of emacs lisp to take a string from the repl and pipe it through XHTML validation.

<comment><USER26> In terms of performance, wouldn't it be far faster to use strings and turn those into document fragments or setting innerHTML? I've been looking at ways to make crate much faster and it seems that would be the fastest solution by far.

<comment><USER27> That's the approach Hiccups took, it goes as far as generating most of the html at compile time as well. I didn't run benchmarks but I would guess it is faster than crate in some situations (huge fragments, older browsers etc).

Another plus is nodejs compatibilty (if you care about that, but I guess you might :)).

<https://github.com/teropa/hiccups></comment></comment></comment></comment>


Zipcar used Wrapify to track offline car ad "impressions" for ad campaign - <AUTHOR> http://www.adweek.com/news/technology/zipcar-launches-new-campaign-featuring-data-tracking-technology-172527 <comment><AUTHOR> Tl;dr

> The company partnered with Wrapify, a San Diego startup that pays drivers to > cover their cars with branding and data-tracking technology. Each car is > equipped with sensors that feed live analytics to clients so they can see > where their ads appear on the road, and how many people can see them. > (Wrapify uses telemetry data from the car to track drivers' real-time > location on a map, and pairs it with anonymized data from other sources to > understand how many cars nearby see the message.)

Am I the only one who finds this creepy?

<comment><USER2> No. It is clearly creepy. It is a natural extension of ad networks, though. I think there will be a market soon enough for glasses that provide ad blocking filters.

<comment><AUTHOR> Yes, unfortunately. It's been a long-time advertisers' dream to match e.g. online ad impressions with real-life buying decisions or offline ads and website visits. Just throw enough sensors at it.</comment></comment></comment>


Show HN: User Growth Bootcamp for Startups - <AUTHOR> http://enroll.growhack.com

<comment><AUTHOR> Hey guys, as you know, the biggest risk for startups today isn't product, it's acquiring and retaining the right users.

Developed in partnership with GrowHack and seed-stage investor Quotidian Ventures, the User Growth Bootcamp is an offline and online 8-week curriculum designed to reduce that risk by thinking deeply about your engine for growth and to learn by actually doing.

Students learn by meeting with a new practitioner each week who's an expert in their domain. One instructor, Ankur Nagpal helped built a viral engine to bring on 200M non-unique users through Facebook apps. Another instructor, Cassie Lancelotti-Young headed marketing at Savored which was acquired by Groupon, and now leads Analytics and Optimization at Sailthru.

The curriculum for the program is based off of a set of online courses which has grown to thousands of students. One GrowHack client and student includes Booktrack. Paul Cameron, CEO at Booktrack relates:

"In just over five months since Bookrack released its Booktrack Studio Web App it's user base has grown 30% every month, with 300,000 users creating more than 3,600 Booktracks in 30 different languages and have spent more than 2.5 years reading - this is without a mobile app which has just been launched"

If you know someone who'd be a fit tell them get more information and apply here by April 7th.</comment>


Stack Overflow Community Reacts Against Stack Overflow Company - <AUTHOR> https://meta.stackoverflow.com/q/387599/3834 <comment><USER2> 1\. Company builds a product with no/minimal ads and uses community involvement to grow.

2\. Company adds more ads to the system to earn money.

3\. Company adds more "features" to make money (for expenses and...to make money).

4\. Company reduces consulting with the community because the purpose of the community, to grow the site and userbase, has been served well and the community's interests conflict, at times, with the company's commercial interests and directions.

5\. Community complains that this is not good.

What would people expect after this? That the company would have a change of heart and go back to how it was years ago? I don't think that's easily possible nor desirable by the company. I'd expect that responses, or the lack of appropriate responses, would be to have those who are unhappy to leave.

<comment><USER3> Circle of life. Stack Overflow came about as a direct solution to Experts Exchange that was doing exactly the same thing.

So now it's up to someone to build a new solution which will last for another 10 years until they too decide to cash in.

Probably the smart move from Stack Overflow is to secretly create the competitor themselves.

</comment></comment><comment><USER4> I deleted all of my Stack accounts several months ago. Not all, but the vast majority of programmers on there exude too much ego, self-centeredness, know- it-allitry, unreasonableness, are too petty and/or are too unpleasant to make me either a. want to ask questions or b. want to answer them. It's not a community but a Twitter soundbite competitive résumé sausage factory. I'd rather struggle and figure out whatever the issue is myself.

</comment><comment><USER5> It's clear now that Stack Overflow was a bait-and-switch play:

1\. get the high quality content through gamification of writing answers and moderating the site with points and badges

2\. once a critical mass of content was captured and the competition eliminated, tell the original creators they were no longer welcome

3\. profit with a new, ad-friendly userbase

<comment><USER6> "Bait-and-switch" implies an intentional plan from the beginning.

What I suspect typically happens is that a company starts with good (or neutral) intentions, grows a community that trusts them. Then it becomes profitable, and a new set of C-levels and managers swoop in with a completely different set of values, to exploit and squeeze more profit out of the community they never contributed to building.

<comment><USER7> Sure but the original intention makes no difference to the user base, particularly those who've put in a lot of time and effort for little reward other than community kudos.

I suppose there's a deeper problem of the difficulty of ethical profitability over the long term. We seem to see this same pattern again and again with startups that seem to grow out of their good intentions, particularly with social media or otherwise community driven websites.

</comment></comment></comment><comment><USER8> I feel like I'm out of the loop here, what specifically have SO done to piss people off? What are the actual features they have they added that people are annoyed about?

</comment><comment><USER9> They need some good old-fashioned competition to light a fire under their butt. The Network-Effect is poison to competition, but I hope somebody finds a way around it.</comment>