Visual Basic.CodeCompared.To/Go

Module becomes package main — the package named main is what produces an executable — and Sub Main() becomes func main(). Imports System becomes import "fmt", naming the package that holds the printing functions. Blocks use braces and there are no semicolons; the compiler inserts them at line ends, which is why the opening brace must stay on the same line. Indentation is tabs, decided by gofmt rather than by you.

Go has no $"...". fmt.Printf uses C-style verbs — %s, %d, %.2f, %05d — and needs an explicit \n, while fmt.Println supplies one. The verb with no .NET counterpart is %v, "print this value however it should look", and %+v, which adds struct field names. Between them they replace most of what you would write a ToString override for.

An unused local variable or an unused import is a compile error in Go, not a warning. This is jarring while you are experimenting and valuable in a codebase: dead code cannot accumulate. The escape hatch is _, the blank identifier, which discards a value on purpose — you will use it constantly for return values you do not want. Unused struct fields, function parameters and package-level variables are all still fine.

:= declares and infers in one step and works only inside a function — it is what you will write nearly always. var name Type is the explicit form, and it is what you need when there is no initializer, at package level, or when the inferred type would be wrong. The type goes after the name, reading left to right: var ready bool. Const becomes const, and constants are untyped until used, which lets one constant serve several numeric types.

A name beginning with a capital letter is exported from its package; a lower-case one is not. That is the entire access-control system: two levels, package and exported, with no Protected, no Friend and no per-class privacy. It has a real consequence for naming — renaming a field changes its visibility — and it means you can tell at a glance, at every use site, whether something crosses a package boundary.

gofmt ships with the compiler, runs on save in every editor, and is not configurable. Tabs for indentation, a fixed brace position, aligned struct fields. The effect is that all Go code looks alike, code review never discusses layout, and a diff only ever shows a real change. Coming from a language with no such tool this feels authoritarian for about a week and then becomes one of the things you miss elsewhere.

Numbers start at 0, strings at "", booleans at false, pointers and slices and maps at nil, and a struct at a struct whose every field is its own zero. Note the difference from Visual Basic: an uninitialized String is Nothing there and "" here, so a zero-value Go string can be used immediately. The design goal is that the zero value should be ready to use — a zero sync.Mutex is an unlocked mutex, a zero bytes.Buffer is an empty buffer.

A struct is data only. A method is a function with a receiver — func (p Person) Describe() — written at package level rather than inside the type, which means you can add methods to any type your package defines. There is no constructor: the convention is an ordinary function called NewPerson. And because a struct is a value type compared field by field, == works on it directly, with no Equals to override.

Everything is passed by value. A pointer receiver, *Counter, is what lets a method change the original, and &value takes an address. Go smooths the calling side: counter.Increment() works on a value because the compiler inserts the &. There is no pointer arithmetic and no manual freeing — this is a garbage-collected language — so a pointer here is closer to a .NET reference than to a C one. The rule of thumb: use a pointer receiver if the method mutates or the struct is large, and be consistent within a type.

Go performs no implicit numeric conversion at all, so int plus float64 is a compile error until you write float64(whole). String conversion is not a cast: strconv.Itoa for int→string, strconv.Atoi for string→int, strconv.FormatFloat and ParseFloat for floats. Note that Atoi returns two values, the result and an error — which is the subject of the errors section and the single biggest difference in this whole comparison.

List(Of String) becomes []string. Add becomes append(slice, item), and you must assign the result: appending may allocate a new backing array, so append(fruits, x) on its own is a bug the compiler will flag as an unused value. Count becomes len(), a built-in function rather than a property. Slicing with [low:high] gives a view onto the same memory, which is fast and — as the gotchas section shows — occasionally surprising.

Dictionary(Of K, V) becomes map[K]V, and ContainsKey/TryGetValue both become the comma-ok form: value, ok := ages[key], where ok says whether the key was present. Without it you cannot tell a stored zero from a missing key. The other thing to know: map iteration order is deliberately randomized — it differs between runs of the same program — so any output that must be stable needs the keys collected and sorted, as above.

For Each x In items becomes for _, x := range items. range always yields the index first and the value second, which is why the blank identifier appears so often: you usually want only the value. Over a map it yields key and value; over a string it yields byte offsets and runes. for i := range 3 counts 0, 1, 2, which is the closest thing to For i = 0 To 2. Note ToUpper is a package function, strings.ToUpper(word), not a method — strings are a built-in type with no methods of their own.

The condition takes no parentheses and the braces are mandatory, even for one statement. ElseIf becomes else if, and the else must sit on the same line as the closing brace — a consequence of automatic semicolon insertion. The addition is the init statement: if value, err := ...; err != nil declares variables scoped to the whole if/else chain, which is the idiomatic way to handle the two-value returns Go functions produce.

Go's switch does not fall through — each case ends by itself, so no break is needed anywhere, exactly as in Select Case. Several values share a case with a comma, matching Case 2, 3. A switch with no subject takes boolean cases, which is how Case Is > 100 translates. There is an explicit fallthrough keyword for the rare deliberate case, and Case Else becomes default.

There is no while and no do: for condition { } is a while loop, for { } loops forever, and for init; cond; step { } is the counted form. To 5 becomes <= 5, the usual off-by-one to check. Exit For becomes break and Continue For becomes continue, both of which accept a label to act on an enclosing loop. There is no Until, so a Loop Until condition gets inverted or becomes a break.

Go has no conditional expression. Both forms of If() become an if statement assigning to a variable declared just above — which is more lines and, the language designers argue, more readable when the branches grow. There is no ?? and no ?. either. This is representative of Go's whole approach: fewer ways to express a thing, and the one way is usually the plainest.

Sub becomes a func with no return type; Function ... As Integer becomes func ... int. Parameters sharing a type may share the annotation, as left, right int does. A lower-case name is package-private and a capital one is exported, so announce here is internal. There is no overloading: two functions cannot share a name, so Add(Integer) and Add(Double) become AddInt and AddFloat, or one generic function.

A function may return any number of values, listed in parentheses. That removes the need for ByRef entirely, and it is why strconv.Atoi and every map read hand back two things. Results may be named in the signature, as (smallest, largest int) is, in which case a bare return returns their current values — useful for documentation, and easy to overuse. Assigning several at once, low, high := ..., is the unpacking side.

defer schedules a call for when the surrounding function exits — by return, by falling off the end, or by panic. So Using ... End Using becomes f, err := os.Open(...) immediately followed by defer f.Close(), and the cleanup sits two lines from the acquisition rather than at the far end of a block. Deferred calls run last-in-first-out, and their arguments are evaluated at the moment defer is written, not when it runs.

Func(Of Integer, Integer) becomes the type func(int) int, written inline — there is no Func/Action family and no AddressOf, since a function's name already is a value. A function literal captures the variables in scope, so makeCounter hands back a function with private state, which is Go's answer to a small stateful object. Each call to makeCounter gets its own total.

Go has no exceptions and no Try/Catch. A function that can fail returns an error as its last result, and the caller checks it — immediately, every time. if err != nil { return err } is the most common three lines in the language, and the verbosity is the deliberate trade: you can see every failure path on the page, and no error can travel silently past a caller who did not think about it. Returning nil for the error means success.

fmt.Errorf with the %w verb wraps an error, adding context while keeping the original reachable — the equivalent of passing an inner exception. errors.Is(err, ErrNotFound) then asks "is this, anywhere down the chain, that sentinel error", replacing Catch e As NotFoundException. errors.As is the version that extracts a specific error type so you can read its fields. A package-level ErrSomething value is the idiomatic way to let callers recognize a condition.

panic unwinds the stack running deferred functions, and recover — callable only inside a defer — stops it. So it can be made to behave like Try/Catch, as above. But it is not for ordinary failures: it is for programmer bugs, such as an index out of range, and for a library boundary that must not take the whole process down. A file that does not exist, a malformed number, a failed request — all of those are error values. Reaching for panic where an error belongs is the most common way ported .NET code reads wrongly in Go.

Go interfaces are structural: a type satisfies an interface by having the right methods, with no declaration on either side. The consequence that matters is that the interface can be defined by the consumer, after the fact, for a type it does not own — including types from someone else's package. Go convention keeps interfaces small (one or two methods, often named -er: Reader, Writer, Stringer) and defines them where they are used rather than where the implementations live.

Go has no inheritance, no Inherits, no Overridable, no MyBase. Embedding a type puts its fields and methods on the outer type, so Dog answers Describe for free and can define its own Speak to shadow the inner one. The crucial difference from overriding: this is not polymorphic — a method on Animal calling Speak gets Animal's, never Dog's. Polymorphism comes only from interfaces, which is why Go code is designed around them.

Defining String() string makes a type satisfy fmt.Stringer, and every printing function uses it automatically. That is the structural-interface idea doing real work: no Overrides, no base class, just a method with the right name. Note also that Go has no Decimal: float64 is the practical default and is wrong for money, so a real accounting service uses integer minor units or math/big's Rat.

go f() runs f concurrently. A goroutine is far cheaper than a thread — thousands are routine — but it returns nothing, so there is no Task to await. Coordination is separate: sync.WaitGroup waits for a set of them to finish, and sync.Mutex guards shared state, exactly as it would in .NET. Note that unlike JavaScript this is real parallelism across cores, so a data race is possible and the mutex is not decorative.

A chan int carries values between goroutines; out <- value sends and <-channel receives. An unbuffered channel blocks until the other side is ready, which makes it a synchronization primitive as well as a queue. close ends the stream, and for value := range channel reads until it closes — the counterpart of GetConsumingEnumerable. chan<- int in a signature means send-only, which the compiler enforces. The community slogan is "share memory by communicating", meaning prefer a channel to a mutex where you can.

select is a switch over channel operations: it blocks until one is ready and takes that branch. Combined with a timeout channel it gives you "whichever happens first", which is Task.WhenAny. context.Context is the direct counterpart of CancellationToken, and Go convention passes it as the first parameter of every function that can block — you will see ctx context.Context throughout any server codebase. It carries deadlines and cancellation down the call tree.

An import brings the package into scope, and its members are always qualified: strings.Join, never a bare Join. There is no equivalent of Imports System.Math pulling names into bare scope, and no way to shorten a call — which is deliberate, since every call then says where it came from. Aliasing exists (str "strings") and is used mainly to resolve a name collision, not for brevity. Remember that an unused import is a compile error.

go.mod is the .vbproj, go mod tidy is dotnet restore, and modules are fetched by URL rather than from a central registry with an account. The differences worth the move: go build produces one statically linked binary with no runtime to install — you copy a file to the server and run it, which is a materially smaller deployment story than shipping .NET. And go test, go vet and gofmt are part of the toolchain, so a project needs no test framework, no linter package and no formatter argument.

Go has no \, and / between two integers truncates — so a Visual Basic / copied across silently starts doing integer division. What limits the damage is that Go performs no implicit conversion: writing (3 + 4) / 2.0 is a compile error rather than a wrong answer, because an untyped integer expression cannot mix with a float variable of the wrong type. Being made to write float64(...) is the prompt to think about it.

A declared-but-not-initialized map is nil. Reading from it returns the zero value and len is 0, so code that only reads works perfectly. Writing to it panics at runtime. A nil map must be created with make(map[K]V) or a literal before any assignment. A nil slice, by contrast, is genuinely usable — append to a nil slice works and returns a real one — which makes the map behaviour easier to forget.

A slice is a length, a capacity and a pointer into a backing array. Slicing does not copy: original[1:3] shares memory with original, so writing through one is visible in the other. LINQ's Skip/Take always produce independent sequences, so this catches people constantly. When you need a real copy, allocate one and use the built-in copy. The same sharing means append can sometimes write into a neighbouring slice's memory and sometimes reallocate, depending on capacity.

Go has no overloading, no optional parameters and no named arguments. Two functions cannot share a name, so Area becomes AreaSquare and AreaRectangle — which the community regards as clearer, since the name now says which one you meant. Optional settings become an options struct, where the zero value stands for "not supplied"; the other common pattern is functional options, a variadic list of configuring functions. Both are more ceremony than Optional, and both survive the addition of a fourth option better.

My.Computer.Name becomes os.Hostname(), My.Computer.FileSystem becomes os and path/filepath, IsNumeric becomes strconv.Atoi and an error check, Now becomes time.Now(). The larger point: Go has no desktop GUI story and no designer. A WinForms application does not port — it becomes an HTTP service (net/http is in the standard library and is genuinely production-grade) with a web front end, or a command-line tool. That is the decision to weigh before any of the syntax on this page matters.