socratic

Every time I read one of these (Github, Etsy, ...), I feel a bit guilty that our tiny startup doesn't do continuous integration/deployment. I mean, we git push to Heroku to deploy (maybe once a week), but there is no automated push once the tests pass. It seems like this is a big psychological leap (deploy every week vs deploy every hour).

When does setting up something like Jenkins CI become worth it? When you have 2 people? 10 people? 100 people?

Is there tons of custom code to set it all up with Github or whatever deployment scripts exist? What CI systems are dominant? (I'm mostly curious about Ruby-centric ones, but don't really want to bias responses.)

  I must hunt down and learn to use a QuickCheck-like library for my language.

  If I can't find one, I should write one.

So what's the (best) equivalent of QuickCheck in Ruby? In other languages?

I completely agree with your analysis. That said, this comment and your blog post seem to have avoided (probably unintentionally!) the two questions that seem to me to be most salient.

1. If you ranked the startups in attendance, do you think a 50th percentile startup would have gotten something useful out of Disrupt? A 90th percentile startup? (If so, in softer benefits like pulling together as a team or in something measurable?)

2. Do you think your traffic numbers for Trello would have looked substantially different on launch day without Disrupt? In 6 months?

In the first case, I wonder if there really are unfunded, 90th percentile tech startups that represent some sort of Cinderella story that just need the spotlight to get funding and attention. In your case, I wonder if 6 minutes on stage compares to a decade of organic SEO and trust (via your blog), running the most popular programming Q&A site, and cross-promotion opportunities from FogBugz, Kiln, Copilot, and others.

What is the goal of startups attending these sorts of conferences (e.g., Disrupt, Demo, Launch)?

It seems like the answers could be publicity, funding, sales, networking, or hype. Publicity doesn't make much sense because articles only usually discuss a few of the (hundreds of?) startups. Funding doesn't make sense because if you're unfunded, why spend money to go to an expensive conference? Sales doesn't make much sense because it's not a specific conference for the specific industry of the startup. (Unless the startup sells services or software to other startups.) For similar reasons, it's not clear to me why it is useful to network with other startups from arbitrary other areas. (Incubators and advisors seem like they would give much better advice than other startups, for example.) Is the goal just to get the startup's name in a list so that investors think things are going well (hype)?

Whenever one of these things happens, it feels like I'm missing out on something by not being part of it. But on the other hand, I really don't understand what the purpose is supposed to be. What are the supposed benefits, and are there actual benefits?

Is this what extremely good organic SEO looks like?

Most of the other names are not really used on the Internet at all. Now, when anyone fails to spell qwikster, they're going to find this article. It seems like they rank for every misspelled query now.

(Google may start spell correcting to qwikster, though for the moment they seem to spell correct to quickstar when they do.)

Are there other variants of this technique?

Do people use things like this?

I recently read Robert Bringhurst's excellent Elements of Typographic Style, but have no idea how to apply it to the web.

(There is an effort to translate the work at webtypography.net, but frankly, most of the sections are some equivalent of "you should do X, but X is not possible right now, but maybe with some CSS extension in the future X will be possible.")

It seems like maybe we have choice of fonts now (through TypeKit, Google Web Fonts). But kerning and justification seem to be mostly accomplished through these sorts of JavaScript hacks, and text figures seem outright impossible. What is a wannabe typographer supposed to do on the web with current tools? Are lettering.js, kerning.js, kern.js, linebreak.js and similar usable or just experiments?

More generally, what does the current web typographer's toolbox look like at the moment?

It's weird to see Y! get a lot of hate on HN, because it seems like working there would be a lot like working at a startup. You're trading off risk (will this company exist in n years) for reward (higher salary, greater control over job responsibilities). The best Y! employees also probably have a ton of visibility, working on projects like Hadoop, YUI, YQL, and so on.

What's wrong with this analogy?

Totally agreed about yearning for a directory of JavaScript frameworks.

I use a little jQuery, and I'm getting to the point where I'm ready to add a little more structure. But should I be using Backbone.js? Spine claims to be cleaner, but how do the communities/plug-ins compare? How does KnockoutJS compare? BatmanJS? Should I be abandoning jQuery for something more extensive like SproutCore or Sencha?

I'm also totally unclear on how compatible things are. A lot of the frameworks don't even seem to agree on basic things like how to do inheritance or whether they should use JavaScript or CoffeeScript. (Though I suppose they mostly don't break each others' namespaces any more.)

Is there some over-arching list of features that covers all of the existing frameworks, and that could be put into a table? If so, does such a table exist? If things are just a popularity contest, who is winning the popularity contest?

This seems interesting, but I'm wondering who the target customer is (both for PiCloud, and for this specific use case with REST publishing).

We're running on Heroku, where workers are expensive (at least, unless you scale them dynamically). We looked at SimpleWorker, which is basically PiCloud for Ruby. But latency for enqueue-ing a job was way too high, and not having access to database models and such made it inconvenient for that purpose. (Long story short, we ended up with Resque like everyone else.) Does PiCloud have the enqueue latency problem beat? (Like under 100ms RTT?)

But these services don't make sense to me for big data or scientific computing either. If you have tons of data, you're probably going to end up with something like MapReduce with some specialized HBase-like backend. And most "scientific computing" I've seen seems to be either MATLAB (if performance is no issue at all) or custom C++ code linking to specific linear algebra libraries (if performance is important). That said, I'm not an expert in either of these use cases, so maybe I'm wrong? Maybe this is for mobile or to fix some brokenness in GAE?

Put another way, what is the use case where you (a) don't care about high enqueue latency, (b) don't care about running within your own infrastructure and with your own code (e.g., for database access), (c) want tons of compute cycles in Python without having to manage the infrastructure, but (d) don't want specific control over the actual infrastructure and data persistence?

I am also confused by this. The name of the startup actually appears to be "Groove Networks LLC".

Obviously, there are a lot of Famous Ray's Pizzas and such, but "Groove Networks" seems so oddly specific. Does this startup have some relationship with the original Groove Networks of the early 2000s?

http://en.wikipedia.org/wiki/Groove_Networks

I'm really curious what Alex's reaction is to the discussion here. He posted a link to the blog post, so he must be reading it, no?

The comments so far seem pretty negative, and not really for unimportant reasons.

The two main issues I see are: (1) too complicated as well as lacking contrast, so it will not print well on t-shirts, letterhead, and business cards and (2) the logo does not look like a shell without seeing the process that produced it (and in fact looks more like a pig, breast, or heart, all of which are kind of weird).

Were there business or other reasons for ignoring these aspects? Would it be possible to change the logo at this stage if this feedback were convincing?

Would/do Jose Diaz-Gonzalez's plug-ins solve your problem?

https://github.com/josegonzalez/josediazgonzalez.com/tree/ma...

I think that's probably true, though I do wonder from a purely engineering standpoint what features Oracle/DB2/MS have at this point that PostgreSQL does not. Special index types? Query hints? Suggestions for physical layout on table creation?

Should I as a web app developer at a startup be looking for an RDBMS beyond PostgreSQL, probably a commercial one?

I have somewhat of a database background, so I see the obvious advantages of PostgreSQL over MySQL. In particular, things like more procedural language support, a better query optimizer, better concurrency control, etc. (Though things like Amazon RDS are compelling from a deployment perspective.)

I fundamentally believe that using an RDBMS, rather than a NoSQL data store is the right approach for rapid development of web apps. (Though, I primarily mean this as an attack on, e.g., MongoDB, since I think Redis is great, just not a replacement for an RDBMS.)

However, I have almost no experience with the more advanced end of the RDBMS spectrum, primarily because they tend to cost money (for the real, non-free versions). Should I be learning/looking at DB2? Should I be learning/looking at Oracle?

Or do the additional features of these more advanced RDBMS options require such specialized scenarios (a bank, a big enterprise) or such specialized hardware (weird clustered setups) that MySQL/PostgreSQL will always be just as good?

I hate citing Reddit, but this un-sourced imgur link makes it seem like he's not such a bad guy, no?

http://i.imgur.com/lTvOg.jpg

I am not sure if this is what you meant, but cogent means convincing.

1. Are you convinced that going forward, Apple's most "sustainable advantage" is economies of scale? Do you believe that consumers primarily buy Apple products based on price?

2. Do you believe that building up economies of scale would take Dell or Samsung a "decade"?

(These are the primary claims in the conclusion of Gruber's essay.)

You seem to have missed an earlier part of my comment. Because HN requires very high karma thresholds before enabling downvotes, net points are an extremely asymmetric measure.

However, one possible solution would be to enable downvotes, but only on controversial posts such as Gruber's. That would enable both sides of the community to speak.

How would you feel about such a measure?

EDIT: Controversial might be defined objectively as the ratio of upvotes to flags, or similar. People regularly comment on the fact that they have flagged Gruber's posts, but I presume that moderators currently just ignore such flags because the content isn't offensive, against the rules, and so on. For that matter, it would be interesting to know how many flags are currently on this post.

I tried to make this point below in a more subtle way, but you take on the issue more directly.

Gruber's arguments never make any sense. Historically, he changes his opinions more or less based on what Apple is currently doing. He adds little value, and it seems clear that he's making a lot of money as a pro-Apple cheerleader from his blog posts. (Which is fine, don't get me wrong, but it doesn't make him a good news source.)

However, I'm not sure how to get rid of Gruber posts. With certain types of posts, HN can feel like an Eternal September.

http://en.wikipedia.org/wiki/Eternal_September

Certainly the first few times I read a Gruber post, I thought there was some legitimate content there. But now, his posts feel largely like regurgitated commentary on discussions had elsewhere, and his opinions feel utterly discredited by their uniformity.

Without downvotes, and without flags removing Gruber posts, I'm not sure what we can do. Could we possibly, as a community, just agree that a blacklist of Gruber posts is good for us? How would we begin such a discussion?

"But at this point, it seems clear to me that however superior Apple's design is, it's their business and operations strength — the Cook side of the equation — that is furthest ahead of their competition, and the more sustainable advantage."

Gruber's argument confuses me:

1. Steve Jobs, the only CEO to ever successfully lead Apple in the company's 25-year history, has resigned.

2. Because of the current popularity of the iPad, iPhone, and MacBooks, Apple has great economies of scale. (However, Gruber primarily gives us anecdotes to support this.)

3. These economies of scale are evidence that the new CEO, an operations guy, will be able to lead the company.

4. In fact, design is copy-able.

5. Therefore, because Apple's designs are copy-able, in terms of competitive advantage, the new CEO has always been more important than Steve Jobs.

Is that correct?

The retitling is definitely useful information. I didn't notice that!

However, you seem to have forgotten to explain the actual argument.

Is the actual argument that sometimes some software, which may or may not include Java, asymptotically becomes old or bad or unchangeable, but that's OK?

I am confused by the point that the author is trying to make. Perhaps someone could clarify?

The argument seems to be:

1. It took 2--5 years to add lambdas to Java.

2. Therefore, Java is like a comb-over. It's old and trying unsuccessfully to cover up that it's long in the tooth.

3. (Possibly?) Java programmers should not program in Java.

I'm not sure that any of these things follow, or if they do, that they have anything to do with Java specifically.

At this stage, Java has existed for 15 years. Once a language has seen serious adoption by regular programmers for a decade, it obviously becomes very difficult to change (for training, IDE, etc. reasons). It's also unclear if programmers of the language necessarily want it to change.

Now, let's be clear. I absolutely despise Java for a variety of aesthetic reasons. I'm as happy as anyone else to have a chance to make fun of it.

However, if we look at C standards, there's C89, C99, C1X. C++ standards, there's C++98, C++03, C++11. These languages, used by millions of programmers (and with very similar syntax, feature set) change every 5--10 years. What exactly is special about Java? Why is the headline here anything other than: "Java: Used by millions, evolves similarly to similarly popular languages used for similar applications"?

I believe you misunderstood my point.

1. People are uncertain whether Google Plus, a centralized social network, will gain significant enough traction to become a force in social networks.

2. Google Plus, in 2011, has had extended periods (weeks, months) where it gained 1M users every 3 days (the number of users in the bet). Thus, orders of magnitude more than 1M users is not sufficient to necessarily be a substantial social network.

3. In 2014, presumably there will be even more users on the Internet, and it will be possible to gain traction even faster than in 2011. Further, a social network might need to be even larger to be a substantial force in 2014.

4. Therefore, why would one set the threshold for "significant" traction for distributed social networks in 2014 at one network with 1M users, when that number may be orders of magnitude too small to be relevant in 2011?

(This ignores the question, of course, of what counts as distributed and/or what counts as a social network.)

Obviously, Google Plus is not distributed, or else one of the people would have already won the bet, since Google Plus already has millions of users!

I am confused, however, by your comment about users rolling over from Gmail. First, do you have evidence for this claim? (If anything, it seemed to be false in the case of Buzz.) Second, how is it relevant?

Those bet terms seem really odd. Your bet is that within 3 years, there will be a distributed social network with at least 1M users? Am I reading that correctly?

Google Plus, which people aren't even really sure is a success yet, had 10 million users in less than a month. Is there some reason that you chose the number 1M as significant traction? If anything, those terms suggest to me that you're not really convinced it's going to happen.

You present an interesting tool for settling such debates. However, I believe the more appropriate URL would be:

http://www.indeed.com/jobtrends?q=git%2C+hg%2C+mercurial%2C+...

Obviously, cvs and svn will be with us for some time still, but those are not distributed version control systems (DVCS).

However, you raise a good question: is distributed version control so much better than centralized version control that we will all eventually be using a DVCS? Or are cvs and svn so much easier to understand for new and/or low quality developers that cvs, svn, and others will be with us forever?

It is difficult to answer your question without knowing your purposes and goals. What aspects do you think would make a quality version control host?

For me, the primary issue is size.

A large number of people use Github. This means that social features like networks of forks of repositories and pull requests are substantially more compelling. This also means that many related websites (bug trackers, project managers) have Github integration. Further, it makes much more sense to design custom desktop apps for Github because it is what everyone uses. Lastly, the more people are familiar with Github, the easier it becomes to suggest it for a project or to contribute to a random Github-based project.

The APIs, UI, and general flow of Github are competently designed, but I do not think these are necessarily the core of its success. (I do believe these parts of Github, however, to be better than the competition.)

Ultimately, Github is in a unique position because of its (and git's) popularity. Social features that would not work on other sites work on Github. I am sure that the developers and designers of, e.g., BitBucket and Google Code are smart people, but without users they feel a little like ghost towns.

This is odd, because I had thought of VCS hosting as very much a commodity before Github.

Ah, very interesting list.

I guess I think of Python differently from the other projects in your list because the choice of DVCS chosen by the core team seems to me to impact the DVCS that someone will choose for their library in the language. I don't really have any evidence for that, however.

Do you think that (a) language communities tend to standardize on the same version control, and if so, (b) that language communities tend to standardize on the version control of the core project for the language?

Git appears to be fast becoming the standard DVCS.

Is there any reason that all reasonably well-run projects should not be using git?

GitHub seems vastly superior to BitBucket, and git itself seems pretty much isomorphic to hg (albeit with worse syntax). (This ignores darcs, bzr, etc., but those never seemed terribly competitive for mindshare.) Furthermore, the network effects (with pull requests on Github, not having to have people learn a new DVCS to commit to your project, etc.) seem huge.

Aside from some new innovation on the scale of switching from a centralized VCS to a distributed VCS, I can't imagine anything that would cause me to try to start a project in something other than git, learn another VCS other than git, or try to convert someone to another VCS other than git. Is this the wrong attitude?

Is there any chance that Python might see the light and switch to git from hg? At this stage, choosing hg over git for reasons that seem increasingly irrelevant (better Windows support at the time, written in C/shell rather than Python) is starting to look like a worse and worse historical decision.

There doesn't seem to be much discussion of the core of Pollak's argument.

Specifically, Pollak appears to be arguing that a key question in language adoption is the historical or recent win rate for projects. (Ratio of Scala projects that succeeded divided by total Scala projects.)

Pollak wants the average doofus Java developer ("COTM" as he terms them) not to use Scala so that Scala's win rate stays high, even if Scala's absolute number of wins remains low.

But having a multitude of doofus developers leads precisely to things that Scala kind of lacks right now, like quality IDE support, idiomatic libraries for every possible use case, and so on. Without the hoi polloi, why spend a massive number of man years developing IDE support that can efficiently parse incorrect source code in the language as correctly as possible? Why write idiomatic payment processor code?

Similarly, focusing on only the best developers has arguably led languages like Haskell and Lisp to be great languages for learning language constructs and new ways to think, but poor day-to-day languages. (Though I do recognize that Clojure is gaining ground, etc.)

In short, is Pollak right? Is win rate so critical to adoption of a new language that Scala should kick out the COTM programmers? Or is he proposing imposing an exclusiveness that will only slow the development of tools and libraries necessary to open up the language to a larger and larger community?

One issue with the current karma-less HN is that one cannot visually determine who won an exchange such as this one.

Is there a mechanism for determining the karma of a particular comment with additional effort?