Why I Program in Go

http://tech.t9i.in/2013/01/why-program-in-go/

by bcl • 14 years ago

204 168 14 years ago

tech.t9i.in

georgemcbay2• 14 years ago

Those are many of the same reasons I program in Go.

To add another:

* Go's build tools and the language's overall approach to building projects are fantastic.

For the vast majority of projects you don't need an external build manager like make. One of my least favorite bits of programming in C and C++, even when I was doing that on a daily basis years ago, was the huge morass of make/autoconf hell that would grow up around projects and would be very difficult to understand and reason about unless you were there for the entire project's development.

With Go open source projects (on git, svn, mercurial) much of the time you can just

  go get http://hosted-code-site/blah/(package)
  cd (package)
  go build

... out pops a working executable.

mitchi• 14 years ago

I have to agree that this is invaluable.

enneff10• 14 years ago

Actually, the "get" command implies "build" and "install", so it's just (a real example):

  go get github.com/nf/todo

and you get a todo binary in your workspace's bin directory.

georgemcbay2• 14 years ago

TIL.

Thanks, that's good to know. Another (related) wonderful thing about Go is how fast everything compiles, so fast that it never occurred to me that go get was building as part of the install.

microtonal• 14 years ago

With Go open source projects (on git, svn, mercurial) much of the time you can just

And have absolutely no version management or any way to indicate API changes (except for making a new repository for every API-breaking change).

codygman7• 14 years ago

The ecosystem makes it more difficult to write bad software. Handle all of your errors, you can't put in things you don't use, it makes testing VERY easy, logging really easy, and if you have testing you have performance testing for free with it.

Not having version management is a real concern, but I solve that problem by forking the projects and updating manually as needed. Ubuntu and debian are soon going to be allowing you to install go packages with their package management systems if I'm not mistaken.

voidlogic3• 14 years ago

I love Go for many of the same reasons as the author. Go's fantastic performance doesn’t' hurt either. :)

These micro-benchmarks match what I have seen in the real world:

http://benchmarksgame.alioth.debian.org/u64q/which-programs-...

pron11• 14 years ago

They sure do. Slower than Scala and requiring more code and lacking the awesome power of the JVM. Great choice, indeed.

voidlogic3• 14 years ago

Yeah- that is great as long as you don't care about using 30x times more memory.... The awesome bloat cough I mean power of the JVM in action.

Go vs Scala: http://benchmarksgame.alioth.debian.org/u64q/benchmark.php?t...

It will be interesting to re-visit this when Go 1.1 is out as well. Go being even younger than Scala has a lot of low hanging optimization fruit. :)

P.S. If Go didn't exist I would still be using Java/C#/C/C++ for everything. (I still use Haskell/Prolog where needed)

danso2• 14 years ago

I want to try out Go...but I have to make one initial observation...It can be somewhat hard to Google (ironically) for Go programming examples. I'm sure there's some tinkering you can do in your search query to get slightly better results, but "Go" is a difficult proper pronoun to facet a search around.

https://www.google.com/search?q=go+facial+recognition

https://www.google.com/search?q=python+facial+recognition

PuerkitoBio• 14 years ago

search for golang, most relevant resources will be found with this term.

Edit: also, for package discovery, godoc.org. But golang+anything usually works.

danso2• 14 years ago

I was wrong to doubt Google's foresight.

kristianp• 14 years ago

This was never a problem for me when I was using go. Just use golang in your search terms.

rartichoke• 14 years ago

Golang is pretty popular to search with. Also an interesting thing to note is the main page (golang.org) has an awesome amount of information.

Couple that in with a few Google I/O videos on Youtube and you seriously have enough information that you almost don't have to Google for anything.

jvm• 14 years ago

They seriously need to implement

    go ogle <packagename>

steveklabnik• 14 years ago

I just can't get that hyped about Go, but I will tell you (as a Rubyist, primarily) I've really been enjoying Rust. While they're not directly competing, my experience is similar to the author's PHP -> Go, which is why I comment. I have programmed significant projects in statically typed languages in the past, but this new batch of languages (Rust/Go/Scala/etc) are certainly neat.

pron11• 14 years ago

For the life of me I can't understand why anyone would give up the power (in terms of profiling, monitoring and ecosystem, and somewhat better performance, too) of the JVM, for a language marginally more convenient than Java, and arguably less expressive than other JVM languages. The only thing I could think of is a smaller RAM footprint, if you care about that sort of thing.

Whenever Go is compared to Java, the arguments in its favor seem kind of fuzzy. After all, one of the motivations behind Go was a C-like language with far better compilation time than C++. And Java already fits the bill. So, yeah, Go is leaner and more modern -- but certainly not by an order of magnitude, like other JVM languages. Here, too, the author says that he didn't like Java's IDEs (really? does Go have better tooling? Because Java IDEs really get the job done), frameworks etc. But those things are simply the result of years of changing fashions. Newer Java "frameworks" are just as lean-and-mean as Go.

There are so many new and exciting languages around, but Go seems to carry the least "oomph" of the lot. It's basically Java. A little nicer; a little slower; a lot less powerful.

realrocker• 14 years ago

>Here, too, the author says that he didn't like Java's IDEs (really? does Go have better tooling?

You should really write a GO code to understand what the author means. Writing GO code has no frills. And I have seen nothing cooler than: http://gofmt.com/.

pron11• 14 years ago

Even if that's the case, Go just brings too little to the table. And if you think gofmt is cool, take a look at Project Jackpot [1], or its use in the NetBeans IDE [2].

[1] https://bitbucket.org/jlahoda/jackpot30/wiki/Home

[2] http://netbeans.org/kb/docs/java/editor-inspect-transform.ht...

zaphar7• 14 years ago

My day job involves working with Java and C++ on 10+ year old systems. All of my hobby or side projects are in Go these days with occasional diversions into haskell, ML or various Lisps.

So I'll try to impart some understanding of why I would switch to Go from Java or C++.

First lets get some things out of the way. Go is fast enough and getting faster very quickly and it definitely has a smaller memory footprint. So when compared to java and C++ in those dimensions it holds up just fine but that might not be enough to sway someone over to the Go camp.

It's about what else Go has:

* Go is a batteries included language. The stdlib has almost everything you need to get started much like python does.

* Go is fast for development. I mean really fast. I mean like using Lisp in a REPL fast (almost). I really can't express how fast it's development speed is adequately just trust me its really really fast. This is not just about how fast it compiles although that's part of it. (I've literally been able to write, compile, and run a go "script" faster than an equivalent python script.)

* Go makes concurrency easy to get right. I haven't seen any other language get this so right since Erlang.

* Go is concise. There is no wasted typing. It's easy to read and it's easy to write. Every feature of the language is orthoganal. And it tells you quickly when you've done it wrong.

* Go does OO right. Code reuse through composition not inheritance. Polymorphism through interfaces not inheritance. I never have to worry about it with Go. C++ or java? yeah I've got some inheritance related war stories there.

All of these things exist in other languages but Go is the only language where they all exist together. This is reason enough to switch to Go but there's more.

Go's future is bright. I don't say this because it has celebrity tech people behind it. I say this because the foundation they are laying demonstrates the core team knows what they are doing. Here's some examples.

* Go comes with all the tools you need to programmatically understand Go code. Parser, Type checking, Static analysis is all available via the stdlib. As a result GoCode which adds IDE functionality to the EDITOR of your choice came on the scene very quickly. Java doesn't have this. C++ doesn't have this. Go made it possible to create an IDE as a service with minimal effort. Besides Gocode you also have gofmt. Never worry about code formatting again. gofmt will reformat it for you and it will never break your code. It's 100% safe. I am aware of no other language excepting lisp with this functionality.

Lastly I want to address your "a lot less powerful" comment. I think it's false. In now way is Go less powerful than Java. It's fast enough to be in the same league as java. It has a lower memory footprint than java. It compiles faster than java. And the language itself is if anything more powerful and expressive than java. It has closures, It has interfaces that are just as typesafe and yet easier to use than java.

In fact I'll sum it up in one word: Go is relaxing.

tocomment• 14 years ago

How did you write a go script faster than a python script? That sounds intriguing.

pron11• 14 years ago

Oh, I don't doubt many things can be done much better in other languages than Java, only why stop at Go? Clojure pretty much hits every single one of your requirements, it's more modern and expressive than Go, gets concurrency better, and it's about as slower than Go as Go is slower than Java -- and getting faster. Also, you don't have to give up the monitoring and instrumentation the JVM gives you, as well as the vast Java ecosystem.

I'm not saying Go isn't better than Java -- I'm sure it is. My main point is this: if I want to relax, there are more relaxing languages than Go; if I really need JVM-like performance, I'd rather go with Java and not relax as much; and if I need both -- there's Clojure, Scala, Kotlin (soon).

This leaves one point: RAM footprint, which I'll concede. But stacking that against the JVM's monitoring and large ecosystem, I'll take the JVM any day. So, Go is nice. Really nice. But not nearly nice enough to even consider abandoning the JVM (unless you're memory-constrained, in which case the JVM was never an option).

Also:

> Go makes concurrency easy to get right. I haven't seen any other language get this so right since Erlang.

I'm not so sure about that. If I'm not mistaken, most Go objects are mutable and can still be passed as messages.

> Go comes with all the tools you need to programmatically understand Go code... Java doesn't have this.

It does since Java 6: http://docs.oracle.com/javase/6/docs/jdk/api/javac/tree/inde...

estavaro• 14 years ago

You need to be commended for defending Go.

I don't think the Go developers hide the fact that they mean go as a Systems level programming language. It has higher level features, but the developers don't really mind the fact that Go isn't going to be delivering a whole lot of high level features. Maybe if they come in the form of libraries...

Funny thing about Go is that as a compiled language, folks often need to send the source-code to the deployment servers to compile on them too. I seem to recall that deployment servers shouldn't need to have development tools which were themselves exposing the servers to bad intention by bad folks. It's just hard to keep the separation I guess.

Go error handling is not to be taken lightly just because you can ignore error codes or just print the error and be done with it. I seem to recall that the core developers of Go demanding that Go users try harder to handle errors. Something the compiler doesn't really "enforce".

I prefer Dart to Go because Dart starts from a higher level of abstraction already. Also Dart has been the result of two years of development even if many of the Dart developers also had plenty of experience with developing past languages and tools.

OOP already gives us a lot of bondage and discipline. No need for more incentive by the compiler. Sometimes a couple of extra tools can help our hands without it being forced by the compiler with every run. Say a tool that helps to tell us which methods or variables aren't being used. Go forces us to deal with that on every compiler run. (Even if it can be disabled, but the Go developers prefer to avoid proliferation of config options.)

It's good to have Go and Dart around. So it's not just legacy (Java) and Microsoft (C#) dictating the standards.

pkulak2• 14 years ago

I have a hard time believing anything can beat or even match the garbage collection performance of the JVM. Not that there is something special about the JVM, just that there have been _so_ many smart people working on the problem for so long now. And for good performance doing server tasks (ie, not computational tasks) exceptional GC is a must. Can a GO program handle a workload that creates tens/hundreds of thousands of objects per second for weeks or months without leaking memory? That's why I use Java. If I don't need that kind of performance, I use Ruby. I'm still just not sure where GO would fit into my workflow, though it looks really promising. Especially the concurrency model that you currently have to awkwardly bolt on to Java with something like Akka or JetLang.

Peaker2• 14 years ago

> Go makes concurrency easy to get right. I haven't seen any other language get this so right since Erlang.

I don't understand this: You claim you've used Haskell? Haskell beats Go's concurrency out of the water.

Not to mention conciseness...

patrickg2• 14 years ago

+1. For me a killer feature is that I easily create executables for lin/mac/win on my machine and don't have any dependencies at all (JVM for example).

Raphael_Amiard• 14 years ago

Just one point :

> C++ doesn't have this [Tools for writing IDEs quickly]

Well indeed it does, libclang does exactly that, and quite well. As a result, you have plugins for Vim, Sublime Text and others providing autocompletion and in editor compiltation and error reporting.

enneff10• 14 years ago

Go programs don't just use less memory, the language makes it possible to control memory allocations.

With the JVM-based languages I'm familiar with, it is difficult to control the memory allocation characteristics of you program, and typically the further the language deviates from the JVM's model (eg, Clojure and Scala) the more garbage must be generated (usually in doing= things like runtime type reflection).

All these allocations put pressure on the garbage collector and, fortunately, the JVM provides a few sophisticated garbage collectors. But even so, I am aware of some high profile companies whose JVM-based servers spend upwards of 80% of their CPU time in the garbage collector. It's just crazy.

On the other hand, the Go language and - critically - its libraries were designed to give the programmer control over the allocation patterns of the program. This creates less work for the GC, and leads to leaner services with predictable performance characteristics.

Go has other advantages over the JVM as a platform, but this is the critical one IMO.

Locke16895• 14 years ago

I don't see anything special in Go for commanding the GC, can you point me to these APIs?

pron11• 14 years ago

The only reason you hear less "crazy" Go GC stories is because Go has never been tested as much as the JVM under different application requirements. And if high-profile companies have servers that spend 80% of the time in GC -- well, they must have really neglected their code. That's a result of poor software maintenance, and I doubt any language could help them.

spullara• 14 years ago

If they are spending that kind of time in GC, they are doing something insane. They should send email to hotspot-gc-use and get it solved.

http://mail.openjdk.java.net/pipermail/hotspot-gc-use/

martinced3• 14 years ago

"Java IDEs really get the job done"

That is utterly misleading. Java IDEs really get the Java job done. And, sadly, Java is a language of such an incredible verboseness and containing so many idiosynchrasies that it takes a lot of code to do things. And IDEs do certainly excel at this.

But you have to realize that a lot of the IDEs' functionalities when it comes to Java are really just work around Java's failures.

So, yes, I can fire IDEA and it shall allow me "easily" work around a 100 000 LOC codebase.

But if I can write the same program in 30 000 LOC of Go or 10 000 LOC of a Lisp dialect I think that there's still a jury out there trying to determine if Java IDEs are really that great.

So I don't doubt that IDEA / Eclipse is helping you in your Java + ORM + XML hell but there are other ways to develop applications. Mind you: it's a huge world out there and despite your beloved IDEs being so great there are still people not programming in Java.

Also the IDEs tend to suck quite a lot when we're talking about "non-Java JVM languages".

Btw I'm using IntelliJ since so long I don't remember if it was version 3 or 4 and I just bought version 12.

-- "Patterns means I have run out of language"

jmspring• 14 years ago

For me, Go aside, I just don't want to deal with the JVM. Sure, VMs are great -- erlang has a nice one, iterations of the JVM are still nicer than they were circa 1998, etc. But, I've dealt with services web services in C/C++, PHP, Python, Go, Java, etc. 5-10 years ago, Java and it's assorted frameworks had it's place, but the intersection of Jetty, JBoss/Tomcat, Glassfish, and plain old Java apps muddied the waters about managing Java apps. If you use a framework, you will need to tweak memory settings to make sure things behave well.

green7ea• 14 years ago

I program to solve problems. I usually solve the problems in my head or on paper before doing any coding.There is usually a step afterwards during which I translate this solution into a given programming language. This step in Java is much harder than I would like.

The reason for this is that I feel I spend too much time doing taxonomy and managing complex relationships between different classes when programming in Java. This occurs in every programming language but I find Java is by far the most restrictive in this regard. I find go much more flexible, as much as python, and scheme even more so.

The end result is that I am more productive when programming in these languages and most importantly I feel that I am not doing as much busywork. This in turns makes programming more fun and rewarding.

zxcdw• 14 years ago

Have no fear, Go will not take your Java jobs away :)

smegel• 14 years ago

Does Java do coroutines/green threads? No. At a deep architectural level, the segmented stack required to do green threads is what sets Go apart. And if it wasn't for this, Go could have just been another JVM language probably. I guess they felt this was important enough to justify building their own runtime.

djhworld5• 14 years ago

For my day job I program in Java doing enterprise stuff, at home I enjoy dabbling in Go, D, Haskell and Clojure for personal projects.

Mainly because in my opinion it's a huge PITA to do command line stuff in Java and distributing class files/jars to other systems is a real pain especially when other instances have varying versions of the JVM running.

With Go I can just compile something on my machine and send the executable to another (running the same/similar OS) and I can be pretty sure it runs fine.

Java is great for large, long running applications like web apps and servers, but I don't think you can be as productive when knocking out one-off scripts/rough and ready prototypes.

nnoitra• 14 years ago

We don't care you why program in Go.

kicktheshoe2• 14 years ago

exactly. Wonder how many of these are upvoted by Google staff.

EDIT: and dissent downvoted by google staff?

codygman7• 14 years ago

I care

TallboyOne2• 14 years ago

If anyone is interested in learning go, my site has a compiled list of tutorials and so on

http://pineapple.io/resources/tagged/go-language?type=tutori...

ternaryoperator• 14 years ago

The recent five-part tutorial on Go that ran in Dr. Dobb's also has articles worth linking to: http://www.drdobbs.com/240008277

TallboyOne2• 14 years ago

Added

theyak• 14 years ago

I have been unable to find a good web server tutorial. Everything seems to be listen, process page, done, repeat. This doesn't seem to allow multiple connections at once, especially if the process page process takes a long time.

enneff10• 14 years ago

Go's net/http package is concurrent behind the scenes; each request is handled in a separate goroutine. You just write your HTTP handlers in the obvious way and the concurrency is taken care of by the runtime.

http://golang.org/doc/articles/wiki/

martinced3• 14 years ago

His second point is, to me, the most important for would-be language designers:

Standardized formatting: A standard tool to enforce formatting rules that is not subject to change based on the team members' or leader's opinions is a welcome feature for lowering the "not my code" mental barrier.

This is a godsend. The best thing to have happened to our industry since a very long time.

But his first point is oversimplified:

The compiler not only checks for code that can theoretically result in a runnable program...

It's not exactly as if Go did solve the halting problem or we'd ALL be using Go. So I think a bit more in-depth explanation would have been welcome.

tikhonj• 14 years ago

In a certain sense, languages like Agda do solve the halting program, but we're not all using them...

Seeing more total languages used in industry would be pretty cool.

chimeracoder2• 14 years ago

Slight correction

> The compiler not only checks for code that can theoretically result in a [logically correct], runnable program...

Some examples of this:

- If you try to assign to a variable that will never be read, this is a compile-time error.

- If you try to import a module that will never be used, this is a compile-time error.

- If your dependencies don't form a DAG, this is a compile-time error.

Incidentally, not only does this make runtime errors (or logical errors) much less common, it also makes Go code more readable and vastly contributes to its impressive compilation speed.

kicktheshoe2• 14 years ago

If the biggest gain for the language is a formatting utility then that language is not worth learning.

jlgreco7• 14 years ago

What is the "biggest" gain a language can have is a matter of taste. Someone who considers the handling of formatting and style to be the "biggest" is likely to be one who values those things highly.

That you do not value those things as highly is not particularly profound. It doesn't mean that he is wrong to be excited about that, nor that he is excited about the wrong language, nor even that there is no reason for you to be excited about that language. It only means that there is no reason for you to be excited about that language for that particular reason.

jff• 14 years ago

The formatting utility is really just a side effect of the decisions to Go team made regarding syntax and semantics in the language. There's also a tool to automatically update your code if the language changes (this was important during the days of rapid churn, where your programs would break every week).

They made some very opinionated choices and have largely stuck by them. You can't have an unused variable, it just won't compile. What a pain, right? Well, if there's one thing I've learned from compiling open source code, it's that you CANNOT trust programmers to clean up their code before releasing it--just play "count the unused variable warnings" next time you compile pretty much any Linux program.

djhworld5• 14 years ago

The biggest gain is coroutines which are easy to add to your application. No imports, no convoluted thread initialisation just

    go myMethod()

ericbb4• 14 years ago

> Now, you might want to ... acquaint yourself with [dataflow variables and declarative concurrency] because [they are] the centre-piece of Go's language features.

Not so. Go has native support for neither dataflow variables nor declarative concurrency. Go does have native support for message-passing concurrency--but that's different.

code_martial2• 14 years ago

You're right about that. However, I find it easier to understand Go's concurrency model by starting with dataflow and then adding one more requisite (channels), than starting with classic fork-and-join and then making a bigger jump to message passing concurrency.

c141charlie• 14 years ago

Go nails code readability and documentation better than any other language I'm aware of.

For example, look at the package documentation for Go's list data structure at http://golang.org/pkg/container/list/.

5 seconds of reading this you immediately get what the package does and how to use it. Now let's say you want to know how the list is implemented. No problemo. Click the package files link list.go, http://golang.org/src/pkg/container/list/list.go, and you're presented with very readable source code.

Now compare this with Java. I just Google'd Java List. First link is this: http://docs.oracle.com/javase/6/docs/api/java/util/List.html

Documentation looks OK, but wait, this is the interface. I want to see docs for a concrete implementation. I'm tempted to click on the AbstractList link, but oh wait, that's just another non-concrete class that other List classes probably inherit from. Let's see, let's go to the ArrayList ... this looks good. http://docs.oracle.com/javase/6/docs/api/java/util/ArrayList...

Nice. I wonder how they implemented this. And I'll keep wondering because I can't find a link to the source code. Maybe there is a link to it, maybe not. We're talking about Oracle so without knowing better, I'll assume there is not ...

Let's try Scala. Google "Scala List". Click on first link. http://www.scala-lang.org/api/current/index.html#scala.colle...

What the fuh is a "sealed abstract class List[+A] extends AbstractSeq[A] with LinearSeq[A] with Product with GenericTraversableTemplate[A, List] with LinearSeqOptimized[A, List[A]]"

Oh sweet, this thing has all kinds of methods, i.e. ++, ++:, +:, /:, :+, ::, :::, :\

Reading further, I see section in the documentation called "Shadowed Implict Value Members". Wow, I have no idea what that is.

Looking back to the Go documentation, I immediately "relax" as another commenter put it.

For some reason, I think Scala will end up being the next Java. It has so much momentum, runs on the JVM, has seamless interop with Java code. Has the Play Framework, AKKA, and thousands of other awesome libraries written for it. And if Scala powers Twitter, then I think this answers the scalability and concurrency question.

While I'm bullish on Scala, at the end of the day, I find Go's simplicity make it more beautiful than any other language.

rorrr2• 14 years ago

> Go nails code [cut] documentation better than any other language I'm aware of.

That's because you haven't seen PHP's documentation.

Look at your Go's list example.

It doesn't even show how to create a list and fill it with items.

It doesn't have users' comments.

It doesn't explain much about the data structure. Can it be a circular doubly link list, for instance?

Is there a method to empty the list, or quickly insert more than one element?

Instead it has strangely named sections (like "type Element") that aren't obvious to somebody new to the language.

Sorry, but this documentation is shit.

enneff10• 14 years ago

That's a bit harsh. Library docs are for users of the language. I grant that the list package could use more docs (I personally find it a bad example) but for someone who knows Go, all the important stuff is there.

Juba surprised that you rate the PHP docs so highly, particularly the user comments. Typically those comments contain terrible advice!

codygman7• 14 years ago

Documentation is for documentation by the people who implement the language and know how it should be best used. User comments on official documentation are likely to have tons of different coding styles, so a new user would pick up a lot of bad habits.

If all of the docs are written by go developers/contributors who know that the code in examples should be consistent, then all those bad habits aren't ingrained in new users.

Something golang has that I don't know anyone else has is this:

http://talks.golang.org/2012/concurrency.slide#1

Also another thing about Go, is the source code for each of those packages is extremely easy to understand... it's truly self documenting... there's also the option of looking at the list_test.go file.

I will admit a method to empty the list as well as insert more than one element would be nice.

sambeau• 14 years ago

  "Sorry, but this documentation is shit."

Woah. That's way off the mark. I'm currently having to use both the Go documentation and the PHP documentation and I will take the Go docs anytime.

Yes, they are short of useful examples but, then, so are the PHP docs. Worse than that I find most of the user comments on the PHP docs are noise: self-proclaimed PHP gurus trying to out-clever each other.

The Go Library docs have one major advantage: you can click on the supplied link to see the simple, understandable implementation.

lmm2• 14 years ago

>Nice. I wonder how they implemented this. And I'll keep wondering because I can't find a link to the source code. Maybe there is a link to it, maybe not. We're talking about Oracle so without knowing better, I'll assume there is not ...

If you were using Java the way people do in the real world, from your IDE, you'd already be looking at the source code.

>What the fuh is a "sealed abstract class List[+A] extends AbstractSeq[A] with LinearSeq[A] with Product with GenericTraversableTemplate[A, List] with LinearSeqOptimized[A, List[A]]"

It's an abstract class (generic, and covariant in that generic parameter) that implements some interfaces. It's not hard.

>Reading further, I see section in the documentation called "Shadowed Implict Value Members". Wow, I have no idea what that is.

Take it one word at a time, it's pretty easy. Value - a value. Member - a member of the class. Shadowed - perhaps a scala-specific term, but it means it's in some parent class but hidden because it's also defined in this class. Implicit may be a new and scary concept, but it's pretty core to scala; if you use the language you get familiar with it pretty quickly.

danenania• 14 years ago

Right, you know exactly where everything is when it's your own messy room, but if an outsider wanders in, he can't tell the bed from the curtains.

I grant that there is sometimes a necessary tradeoff between power/abstraction and readability, but readability is still extremely important, and you can't just handwave away confusing language constructs and documentation with "it's obvious after you code in the language for a couple years". Simplicity and intuitiveness are powerful features in themselves.

guilloche2• 14 years ago

I am C and lisp fan and think OOP as non-sense. I used python a bit but hate its performance. Can I still get something from Go that can not be provided by C and lisp? Does go provide great flexibility by C and lisp? BTW, I think emacs is the best IDE so I do not care any tools/IDEs at all.

enneff10• 14 years ago

If you're a C programmer then you will enjoy Go. Try it.

djhworld5• 14 years ago

Go is a bit like C but it has GC so it depends on how much you value the fine degree of control of memory allocation that you get with C.

Personally I think Go has a lot cleaner syntax than C and the tools give a lot more "friendly" error messages when compiling your applications.

You do still get nullpointerexception runtime errors though but that's an inherent problem with the nil/null type.

guilloche2• 14 years ago

Thanks for replying. It seems GO is not for me at least now. What I want is an optional strong typed script language with highest performance. Lisp serves me well here.

I have only three real things to care about a language:

1. Performance and thus optional strong typed is required. Go can have optional strong typed system, so performance may be improved in future, but its GC seems a big warning for me. I want to have option to allocate/free memory myself. the GC is also an enforcement of some design principle, which is also a big minus regarding the next point.

2. Great flexibility, basically the language should not make any decisions for developers. I dislike C++ for its OOP approach to make way too many decisions for developer. I want no limitation from a language. I can self restrain to avoid all troubles from freedom, I can design OOP/GC myself if it is neccessary, but please not make decision for me. (C++ did not enforce OOP, but most of the extra part beyond C usually distorts a good design otherwise) Lisp and C are almost perfect here. Does GO allow any weird design people may think of? any enforcement of some supposed-to-be good principle?

3. A script, which can relieve me on all details. Occasionally, I may not care performance, and I want life easy. Python is prety good here. Lisp is good but lack of compiling on ARM machines is a big disadvantage.

tsahyt• 14 years ago

Thus far I feel that, if any language was ever going to replace C, it's probably Go. In a way I sympathize with Go. I like it for the compactness and simplicity. Those are two design decision which seem to be unique among modern languages and exactly the two things I like most about C.

introspectif• 14 years ago

As an ex-Ruby cum Node.js lover recently converted to Go...

Programming in Go, once it clicks, really does feel relaxing and productive. If you're a decent Node.js programmer, it's like stepping up to "Node Pro", in the sense that you work close to the metal with your web server so everything feels clean and easy to wrap your mind around.

But Go code is cleaner and tighter. The code formatting conventions contribute to that greatly, as well as the fact that you just don't have to pull in as much 3rd party code because so much functionality is already beautifully integrated.

There are a lot of positives about Go that reveal themselves over the first couple days of coding in it.

I do wish the documentation convention included not only a brief description each function, etc., but also a brief example.

By the way, I also evaluated Scala for a few days before settling on Go as my preference. I like Scala, but it quickly becomes a sprawling language as your explore it further, and frameworks like Play and Lift bring even more baggage along for the ride. The core language, on its own, was attractive, but overall, the experience just didn't have the compact, robust, completely under control, and nimble feeling that came with Go.

Oh ya, and the Go syntax felt ugly and awkward at first. That feeling quickly faded after a day of use, but it's worth mentioning because I bet it turns some people away from Go before they even get to the great parts.

Just my 3 cents worth.

agentS• 14 years ago

> I do wish the documentation convention included not only a brief description each function, etc., but also a brief example.

It is getting there. If you run godoc locally with tip, you will find many more examples than there were previously.

See http://golang.org/pkg/path/ for a current example. And the source for those examples can be found here: http://golang.org/src/pkg/path/example_test.go. Note that this technique will work for your own packages as well.

The technology is there, the implementation is still incomplete; but more progress has been made than is easily visible.

asdf3• 14 years ago

The golang website supports other versions; to see the docs for tip go to http://tip.golang.org/

p0nce• 14 years ago

I prefer to use Hypescript for all my kickass cloud deployments.

mcartyem• 14 years ago

Can anyone explain in less than ten words the most important reason to program in Go?

Symmetry• 14 years ago

"Many of the best part of both C and Python"?

af3• 14 years ago

It feels like Go is the new Fortran.

crusso• 14 years ago

Java is perhaps the most depressing language I've ever programmed in.

I'd have to agree with him there.

mark_l_watson2• 14 years ago

"Earlier I mentioned about the JVM being a bad trade-off for phantom portability. In practice, non-trivial Java programs also require porting for different systems."

I have used Java since the beginning (and I have written several Java books). I have had very few portability problems. The JVM is a great ecosystem that supports several fine programming languages.

jhuni• 14 years ago

> Scalars (integers, characters, strings, floats, booleans), sequences (lists/arrays) and maps (key-value pairs) as built-ins are enough to support almost all data models.

There is some wisdom in Larry Wall's decision to make scalars, lists, and maps the main data structures in the Perl programming language and to give them the sigils $, @, %. The considerable wealth of Perl libraries available on CPAN today demonstrates that you can support essentially all data models using these three data types.

Why I Program in Go

Related Stories