Your "-fu" should be considered harmful. | Hacker News Reader

Your "-fu" should be considered harmful.

plus.google.com

46 pointsenneff28 comments

I don't like this statement at all, sorry. It's a very anti-intellectual statement. Are any concepts that are difficult to grasp inherently worth less? That would make all of logic and math bad. Logic is not inherently easy for humans. We are a very emotional and irrational bunch.

I don't agree that technologies are bad just because they are difficult to master. The learning curve is utterly irrelevant to their inherent value. There are lots of things that are both incredibly difficult and amazingly valuable.

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.

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. C++, on the other hand, has been my primary tool for over two decades. The things that appear unreasonably complex to you make sense to me because I am familiar with the reasons they are there. Does that mean that Go is difficult and C++ is simple? Of course not. To someone who doesn't know a thing about programming, they are both absolutely arcane. Even the concept of variables is fundamentally difficult for people to grasp. It's an entirely abstract concept, and abstraction is not easy.

A better measure for the utility of the technology would be to ask how well it solves the problems it is intended for. Empirically, it would seem that C and C++ are both the best tools available for different sets of problems. Go is new, but I don't see it being adopted anywhere outside Google yet. I've looked at it, and while it has some attractive traits, it is fundamentally shaped by a different set of priorities than my own. I just don't find the problems it claims to solve all that problematic.

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.

> 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.

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 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.

I think the main idea here is wrong. There is nothing wrong with technologies that require significant experience to master; the issue is with technologies that require significant experience but are still inefficient.

Plenty of the best tools are moderately difficult to learn: Emacs, Vi, the command line, Linux, Haskell...etc. However, once you learn them well, you become more efficient than you could be on a tool that's easier to learn. And this is good: sacrificing a bit of extra time to learn a technology that will make you more efficient is usually a good trade because learning takes a constant amount of time while being more efficient is at least linear.

The real issue is with tools that are arbitrarily complex. The DOM is a great example: its poor API, browser inconsistencies, weird layout rules...etc do not help you, but are difficult to learn and use. So the real issue is that the parts that are difficult to learn present no advantages over a simpler, easier to learn version.

The browser inconsistencies is the main obstacle, for the DOM, CSS, JS, and ny other web technology dependent on the browser.

I disagree. One could make the same argument about CPUs - look at all the different architectures out there. However, a good toolset (ISO C + autoconf) allows for fairly easy development of code that runs on a very wide range of platforms.

Maybe it's me who missed the point - but I think the author isn't saying "hard things aren't worth it" (as all of the comments here seem to suggest), but he's saying that truly mastering the warts of a technology that is full of warts is a waste of time.

I think the faulty logic there is that _every_ technology over a certain age is going to seem full of warts... so the alternative it keep moving on to trying to master the latest and greatest buzzwords.

Yes, that is what I meant. Thanks for re-stating it so clearly.

To your point, I have two reactions. The first is that I feel you are being pessimistic. To some appearances software seems to be getting worse, but if you step back we actually have some pretty amazing tools these days. I personally find Go a better language than any other I've used. (disclosure: I'm part of the Go team.)

My second reaction is: sure, of course we should move on to new things. We don't drive the same cars we did 40 years ago, yet software moves way faster than the auto industry and we're still using C for a lot of stuff. Programmers should be more adept at re-skilling for new languages and tools. The best ones already are.

CSS is a bit of a hobby horse, no? The specifications and implementations have matured considerably over the past few years, making the ugly hacks of yore unnecessary. If you can afford a somewhat degraded experience on IE7, the experience of writing CSS can be pleasurable and hassle-free.

As to JavaScript: it has also seen massive improvements, but I'd like to emphasize a different point: namely that JavaScript's quirks, while annoying, are hardly arcane. They are very well known, and ably covered by any respectable introduction to the language. Most have established workarounds that are trivial to master (always providing the optional radix parameter to parseInt, for example), and the existence of excellent linters like jslint and jshint (the latter a community-driven fork of the former) makes it trivially easy to remember to do the right thing.

I actually spiked an idea like this a while back ... basically the idea was an in-browser Scheme REPL with something like SBCL's save-lisp-and-die.

Stumbling blocks were my painful lack of familiarity with Lisp development in general, and BiwaScheme's lack of environment reflection. I tried hacking a macro wrapper for definition that saved the definition somewhere serializable but ... yuck.

Perhaps ClojureScript could be a good basis for this (once it's out of alpha and features reflection and whatnot)? One could build a REPL-based development environment (_not_ an IDE!) that behaved somewhat like SLIME, and integrated with all the new hotness (GitHub, Heroku etc. etc.)

Mightn't need much in the way of new technology, so much as a whole lot of nice glue to hold it all together.

You listed potential tools but haven't explained what you're trying to do.

Well, to be honest, I didn't really know ... my plan was to hack around and see what was possible :-)

The vague idea I had was for some sort of modern Lisp-based development environment. REPL-based, rather than an IDE. Targetting HTML5 web browsers (maybe only one to start with?). Social coding baked right in, so it'd be trivial to start projects, fork them, share gists, etc. etc. And then the final step would be publishing to Heroku from within the REPL.

So, maybe start off with an in-browser REPL. Add serialization of state. Then plug that into GitHub. Then some sort of deploy step to Heroku. Lots and lots of keyboard accelerators, help goodness and a decent debugger.

But for the moment, it seems to be beyond my ability and / or beyond existing browser-based Lisp technologies.

Weird that he mentions JavaScript, because it seems to me the simplest language of all. Except for a few quirks that you can usually ignore, what other language is so small and logical (everything builds on hashes and closures, basically)?

If I think of Ruby, I think "ok, I can get things done, but don't get me started with the metaprogramming". It can get seriously metaphysical... Not so in JavaScript.

This statement is just wrong. No matter how many abstraction layers you put on top of a computer, it will be complicated.

Yes they are good, and it's great to be able to do simple tasks with just one line of code but there are points where you can't, or you need better performance, or ,or , or ...

In that case you would need to delve deeper, behind the abstraction layer and you would need to atually understand what's happening down there. If all you know is programming with all these abstractions without understanding what's actually happening underneath then you would be in for a surprise.

And with new technologies coming out on the hardware side all the time, more parallelization, 3D graphics, quantum computing (?maybe), the APIs to use them in software will also be complicated. Nobody said that IT is an easy field.

The poster is discussing technologies known for inconsistency and irrelevant design considerations.

Sendmail pre sendmail X is full of what is now useless code to handle UUCP and X400 mail. JS has a bunch of rarely used cases where objects of different types can be added together to reduce usually unwanted results.

Postfix, Python, and Coffeescript are close to as simple as possible, but no simpler. This is an excellent design goal.

I don't know that JavaScript is so much hard as just different. It's easily to be very expressive in JavaScript and the prototype nature of the language adds power. I think the idea that JavaScript is hard comes from developers that didn't learn it properly or just hack (not in a flattering sense) on it without understanding it.

That having been said, I "understand" CSS, and always feel like I'm hacking on it no matter what I do.

The issue isn't really with JavaScript, which is a great language, but with the DOM. The DOM is rather clumsy and you endlessly have to worry about browser incompatibilities. And if you have to support IE6...

CSS is by far the worst of the technologies I listed, but JavaScript is full of bizarre stuff that can trip you up. The most obvious example is the global variable declaration thing. I've seen highly JS programmers with years of experience screwed by simply leaving out a "var" (in fact, I think something like this was posted to HN not that long ago), but this is something that could easily have been avoided were the language better designed.

Seriously HN?

So now a casual 88-word status post is number 16 on the list?

Correct me if I'm wrong but isn't this list for _hacks_?

What is this? Andrew moping about disliking c++? I couldn't care less.

The quality of HN articles just seems to drop week by week.

I voted you up. Not sure why you are being voted down as you've made a valid point. I found many of the replies awful, for instance one guy states:

"Our children will laugh and wonder how we got anything done with the primitive tools at our disposal."

There are far to many people out there that want to be developers, mechanics, artists, musicians etc etc but give up at the first hurdle and look for something to blame for their failure .. it's a very common human trait and not one I expected to see entertained on HN, either.

I think it's reasonable for my post to be the subject of discussion. As evidenced by the discussion here, there are many views on the subject.

As for that specific comment, I don't know that I agree with it or that you are taking it in the right spirit. It seems to me a light-hearted take on the fact that things that seemed advanced to us 30 years ago seem primitive to us now, and that our descendants might feel the same way in another 30 years. Again, that's not my point, merely a more charitable reading of that comment.

The point of my post was not to blame any of my tools for anything. It was an observation that we shouldn't praise ourselves for mastering the minutiae of environments that suck. We should recognize design failings and try to build better tools. I've personally had great success writing software in JavaScript, among other languages, but that doesn't mean I have to like it.

Reply on news.ycombinator.com