Golang

How does /prague/ feel about Go?

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Printf("Now you have %g problems.",
        math.Nextafter(2, 3))
}

http://tour.golang.org/#5

>>1

Did you mean: gaylang

Google dun goofed.

Not lisp and has no generics. Why should I care?

go's interfaces are pretty nice.

I disagree. Look at this:

(defun list-index (obj lst)
  (if (null lst)
      nil
      (if (eql (car lst) obj)
      0
      (let ((z (list-index obj (cdr lst))))
        (and z (+ z 1))))))

>>7
Lisp is shit and you are a faggot.

>>8

Shit is faggot and you are a lisp.

It's a nice language. I hope it replaces C++ and Java, as well as Python for bigger applications.

Go is gay

>>11
Your gay.

>>12
Witch my gay?

I prefer Brand X: http://www.cowlark.com/2009-11-15-go/

>>10
replaces python
ಠ_ಠ

>>14
The Go code in that article is rather pathetically written (if not outright invalid), examples are trivial (and Go does it better in all of them), and it compares Go to Algol, of all languages.
Go troll somewhere else.

>>15
For bigger applications. For example, think of Deluge. It's written in Python and rather slow. Since Go is about as easy to write as Python, has a nice standard library, targets networking and concurrency and is faster (after all, it compiles to native code), wouldn't it be a good choice for such applications?

Python is shit, but at least it's mainstream shit.

mainscream is the only common selling point of shit languages it seems.

>>17
ಠ_ಥ

golang
http://www.youtube.com/watch?v=_Yfd_7jrnMk

Let's use Microsoft^TM Internet^TM Explorer^TM, because it's  the most used MAINSTREAM browser!

>>16
The point is Algol is a more consistent language. I'd be using Go right now if it had a respectable degree of consistency (and a few semantic changes.) But the Go team decided that "convention" was the order of the day, ruining any chance they had at making a decent language.

>>17
targets networking and concurrency and is faster (after all, it compiles to native code)
It's one of the slowest such languages to target native code. I'm going to plug rust here, because it's done better on all fronts. It has silly problems too, but they're few and far between, not to mention the developers actually recognize the problem areas as problematic.

Google being evil by stealing Francis McCabe's name and replacing it with mediocre shit.

>>14
It's no question that Algol, Pascal, and Smalltalk are better than C, Sepples, and Java.

>>14

Wow Go's union types suck.

My Review of Go Language:
Pros:
*Brings time-tested 1960s Algol functionality to the modern era
*Adds quirks and irregularities to ensure that programmers and documentation writers retain their jobs should it become popular
*Wastes disk space with a brain-dead linker, which would be a boon to RAM and disk manufactures
*Allows nested functions, just like Lisp, Algol, Pascal, Perl, and JavaScript did since the 50s/60s/70s/80s/90s, respectively
*Threads and channels are built-in (really the only interesting feature of Go, a version of "C plus channels and nested functions" or "Pascal plus channels" would have been better)
*Multiple assignment, like Perl and other languages

Cons:
*1MB for Hello World
*Non-standard syntax for C/C++/Java programmers (types after variable names, funky array and pointer syntax)
*Runs on less platforms than C# (with Mono)
*Startup code takes forever (run it in a debugger and see how many superfluous operations are done before the thing actually runs main())
*Linker is shit, you get the whole runtime even if you just use one function
*Might as well use C, C++, or Pascal and get faster, more portable applications
*Might as well use Perl, Python, or Ruby and get easier to write, more portable applications

Conclusion:
Go is shit.

>>16
ANY language being compared to Algol would be an honor. Several of the CS VIP of the 60s participated in it (LISP guy, FORTRAN guy, EWD), BNF notation originated for Algol alone, it just so happens to be useful elsewhere, Knuth devised algorithms just for Algol. All languages other than COBOL and FORTRAN in use right now have features that descend directly from any of the Algols, even bash (Bourne was on the 68 committee). Algol was the state of the art, and compared to a lot of the languages in vogue on TIOBE right now it still is.

It fell into over-design though, even after they had to leave out a bunch of stuff, the language was very extensible, had at least 5 standard encoding representations (book form - yes the language has an ``MS Word'' mode, ASCII-like, and various non-ASCII forms), standard support for keywords in multiple human languages, it had something like 8 kinds of ``nothing'' values.

>>28
even bash

yeah, the

if
  ...
fi

case
  ...
esac

stuff looked familiar

>>28
it had something like 8 kinds of ``nothing'' values.

that sounds insane.

>>30

I can't even think of 8 different nothing english words

null nil empty undefined...nothing...aaand that's all I got.

With the loss of pointer arithmetic, the notational convenience of using pointers for iteration is gone, and I still haven't figured out how to get it back. Quickly looking at the stdlib sources seems to indicate that there isn't one.

>>31
null nil empty undefined nothing void zero none

>>33
Nigger

The Golan Heights Programming Language

>>27
*1MB for Hello World
Statically compile a C hello world program and it'll be about 1.5 MB (GCC 4.6.1 on x86 32bit; gcc -O0 -static $source). And just try the same with a C++ hello world...

>>36

[ Tue Dec 27 06:57:54 ]
[ @ ~/host/prog/he ] $ cat h.c
#include <stdio.h>

void main()
{
    puts("Hello World\n");
}
[ Tue Dec 27 06:58:03 ]
[ @ ~/host/prog/he ] $ gcc -O0 -static h.c
[ Tue Dec 27 06:58:07 ]
[ @ ~/host/prog/he ] $ ls -s -h
total 669K
669K a.out   512 h.c


try again

this guy thinks GO could have been better

http://www.cowlark.com/2009-11-15-go/

Nice article IMO.

>>36,37


[~]-> cat h.c            
#include <stdio.h>

void main(void){
                printf("Hello, World!\n");
}
[~]-> gcc -static h.c -o h
[~]-> strip -s h
[~]-> upx -9 h
                       Ultimate Packer for eXecutables
                          Copyright (C) 1996 - 2010
UPX 3.07        Markus Oberhumer, Laszlo Molnar & John Reiser   Sep 08th 2010

        File size         Ratio      Format      Name
   --------------------   ------   -----------   -----------
    736336 ->    289848   39.36%  linux/ElfAMD   h                            

Packed 1 file.
[~]-> ls -sh h
288K h

You should always strip and pack your executables. Especially if you statically link them.

>>39`
UPX 3.0[b]7[/b]