Hacker News Reader

I look at web development, and a lot of it seems to be tailchasing on the order of "We had to write a framework to get around a bunch of issues with the frameworks we had to work with." And it's turtles all the way down, at least until you get to the OS layers (which, after all, have linear decades of experience behind their design).

I can understand this kind of stuff in a young technology, and indeed things are getting better as people seem to be realizing that architecture astronaut crap like WSDL / JavaBeans / et al did active _damage_ to the industry. (We end-ran OSI with stuff that _worked_, with the exception of X.509 -- ughhh -- and a few other things).

I love hard problems that are inherently hard. I hate "hard" problems that are only there because of a bunch of poor technical decisions (I remember looking at SOAP and getting physically ill).

So much of working with computers is working out ways not to hurt yourself. If there is any "fu" to be learned, it's the ability to look beyond a technology's implementation and into how people will actually interact with it on a daily basis. Make things work well, end to end, over the whole stack. That's what I try to do these days, and I'm a lot happier.

I think there is a distinction to be made: While there is value in grasping things that are complicated or hard to understand, there is little value in designing something that is intentionally complicated or hard to understand. In a certain sense, the problem that a tool maps to must reflect the inherent nature of what it works upon, but the designer of the tool should always intend to make the tool a map more fit for human use.

Many of the things Gerrand cites were not created full form with the problems and uses clearly understood. This led to iteration and backwards compatibility, which introduced complications because now there were many ways to do things and not all suited for each other. I don't think his argument is that everything should be simple, but that the design should not feel iterative and piled upon. Instead it should reflect a consistency of vision for a problem and its solution.

If I may offer an example: In Haskell, the Prelude defines many types and functions which are imported into all modules (sort of similar to namespaces). Many of these functions have commonly understood names but only apply to certain data types. Within the extended set of libraries available in Haskell, there are many other implementations of these functions in terms of more general data types. The types represented are not simple, really, though they are limited and isolated in purpose.

Ideally, if one could go back and rewrite history, these more general functions and data types would be the ones exposed by the Prelude. Instead, the Prelude provides an earlier and less consistent view of common functions and datatypes, while the more consistent view is somewhat obscured inside of a number of neatly organized libraries.

Both the Prelude and the hierarchy of libraries seek to solve the solution of common tools for working with data and functions, but one has a more clear cut and comprehensible perspective while the other has an older, less consistent view.

I agree with you to a point, but I think this is also an issue that is more complicated than it may seem at first glance. A lot of the time, the older, more complex version had some initial design that solved a particular problem but didn't fully consider some alternative use cases.

A redesign might capture these other use cases, but inevitably the evolution of a library also contains a lot of tweaks and fixes for smaller but not insignificant cases that are easily lost in the redesign. Often the new technology appears cleaner at first but then grows more complex as it starts getting used and those corner cases and missing bits accumulate, or it may actually have lost some functionality that seemed arcane to the redesigners but was actually a desired feature by some set of users.

A problem is rarely as simple as it may appear before it is actually deployed and used.

> I also think this statement betrays an incredible short-sightedness. You are looking at the technology you know and think "Wow! This is so simple! Why aren't those things I don't know this simple?" Your technology appears simple to you primarily because it is yours. That's not a relativistic statement to imply that all technology is equally difficult to learn, it's just how our perspective shifts as we internalize new concepts

You are implying that I'm not familiar with other technologies. On the contrary, before I learned Go I was intimately familiar with several other languages. If I hadn't, I wouldn't have any basis to compare or criticize them.

> To me, C++ is a lot simpler than Go. I've tried to grasp how to use things like interfaces and channels in Go, but I haven't quite figured it out yet.

I think the difference between C++ and Go is that you'll understand Go in its entirety within a year, whereas it took you a decade to get there with C++.

See, I just don't agree with you that the difficulty of learning is indicative of the relative value of the two languages. Yes, C++ is very difficult to learn and I'm sure Go is less so (I have a hard time imagining a language more complex than C++). At the same time, I'm not yet convinced that Go is unequivocally better than C++ at the problems C++ solve.

The decade it takes to learn C++ doesn't tell you anything about the value of C++, only that it is more complex. The question is why that is. The backwards compatibility with C is often cited as a prime reason for the inherent complexity of C++, yet that is the very thing that makes C++ "better" for many people.

> Go is new, but I don't see it being adopted anywhere outside Google yet.

1. http://blog.golang.org/2011/04/go-at-heroku.html

2. http://blog.golang.org/2011/12/building-stathat-with-go.html

3. http://www.3dfuture.com.au/2011/12/interview-with-the-tinker...

Heroku is a meta-adoption, not actual use. How much is it actually being used by the users of Heroku? The other two examples are companies I've never heard of.

Of course my statement is hyperbole; I'm sure there are people who use Go, and I didn't intend to hate on Go: I do think it's an interesting language that I am trying to learn. I'm just saying that I haven't seen it in use, and that perhaps the simplicity that its authors are touting lies mostly in their own familiarity with it. Go contains a lot of new and unfamiliar concepts, and it's not trivial to figure out how to best solve a problem using it. But remember that the whole point of my argument is that I don't consider simplicity an interesting criterion for the value of a technology - I can think Go is complex and interesting at the same time.

edit: Relevant information regarding the above examples, from the linked page about Tinkercad: "I also used to work on the Go team at Google so I had used it in production before."

> Heroku is a meta-adoption, not actual use. How much is it actually being used by the users of Heroku?

A huge part of their billing system is written in Go.

> I'm just saying that I haven't seen it in use, and that perhaps the simplicity that its authors are touting lies mostly in their own familiarity with it.

The creators are also expert C and C++ programmers, and have also designed several other languages. Go was born out of frustration with the thorns, inconsistencies, and surprises that plague a lot of languages. My personal experience is with JavaScript - I wrote JS code every day for several years, and still regularly had to use the console to test essential elements of the language, often with surprising results.

We've tried to fix that with Go. Its features are designed to be simple in isolation and predictable when combined. This is the crux of my Google+ post. Our tools should be clean and consistent, so we can spend more time thinking about what we're building, not how the tool might explode if we hold it in the wrong way.

Just as an anti-point to the above...

I'm doing some in depth analysis to see if it's a suitable replacement for C#/.Net framework in our current application stack (message oriented CQRS architecture, web front end). We're doing this by rewriting a chunk of the stack in it and seeing where we get to.

At the moment, it's a very good fit. The time to market is an order of magnitude less than .Net framework. The tooling and mindset is cheaper and easier to maintain and we're not having to invent many solutions to problems - they are already apparent (or just not required).

The only trouble so far has been availabiliy of quality persistence libraries for database engines.

I'm not going to write anything up though until v1 is out and I've ported everything to that and tidied it up.

I don't know if it scales up linearly as the codebase grows yet. This is my only real worry.