Filter interviews by
I applied via Company Website and was interviewed in Jan 2023. There were 2 interview rounds.
Questions related to Go programming language concepts and design patterns.
Pointer is a variable that stores the memory address of another variable, while slice is a reference to an underlying array.
Arrays have a fixed size, while slices are dynamic and can grow or shrink.
Maps are key-value pairs, used to store and retrieve data based on a unique key.
Bridge pattern is used to separate an abstraction from its implementat...
Pointers are variables that store the memory address of another variable. Channels are used for communication between goroutines.
Pointers allow direct access to memory, making it possible to modify values at a specific address.
Channels are used to pass data between goroutines, allowing for synchronization and communication.
Pointers can be used to pass large data structures to functions without copying the entire struct...
Goroutines are lightweight threads of execution in Go that allow concurrent programming.
Goroutines are created using the 'go' keyword followed by a function call.
They are executed concurrently with other goroutines and can communicate using channels.
Switch statements can be used to control the flow of execution between multiple goroutines.
Example: go func() { fmt.Println('Hello, world!') }()
Example: select { case msg :
Explanation of Go path and Go root, and encapsulation with a program example.
Go path is an environment variable that specifies the location of Go source code and binaries.
Go root is the location where Go is installed on the system.
Encapsulation is the process of hiding implementation details and exposing only necessary information.
Example of encapsulation in Go can be creating a struct with private fields and public me
Top trending discussions
I applied via Naukri.com and was interviewed in Oct 2024. There was 1 interview round.
gRPC is a high-performance, open-source RPC framework developed by Google.
gRPC stands for Google Remote Procedure Call.
It uses HTTP/2 for transport, Protocol Buffers for serialization, and supports multiple programming languages.
gRPC is commonly used for building efficient and scalable microservices.
It allows for bidirectional streaming and authentication features.
Examples of companies using gRPC include Google, Netfli
Concurrency is the ability of a program to execute multiple tasks simultaneously. Race condition occurs when multiple threads access shared data and try to change it at the same time.
Concurrency allows multiple tasks to run in parallel, improving performance and efficiency.
Race condition happens when multiple threads access and modify shared data without proper synchronization.
To prevent race conditions, synchronizatio...
I applied via Company Website and was interviewed in Dec 2024. There was 1 interview round.
Asked mostly on grpc.
Couple of coding questions like write the protobuf file for interfaces and gave a string from which asked to find out the valid IP address in that string.
I applied via Approached by Company and was interviewed in Oct 2024. There was 1 interview round.
Golang Basics, DBMS, Channels, Unit Test
1) Search an array element
2) braces balance program
3) anagrams Program
A map is a built-in data structure in Golang that allows you to store key-value pairs.
Maps are unordered collections of key-value pairs.
Keys in a map must be unique.
Maps are useful for efficient lookup and retrieval of values based on their keys.
You can add, update, and delete key-value pairs in a map.
Example: map[string]int{"apple": 5, "banana": 3}
A slice is a dynamically-sized, flexible view of an underlying array in Go.
Slices are similar to arrays but with a variable length.
They are reference types and can be resized.
Slices can be created using the make() function or by slicing an existing array.
They provide a convenient way to work with collections of data.
Arrays have fixed length, while slices are dynamic. Slices are references to arrays.
Arrays have a fixed length, while slices can grow or shrink dynamically.
Slices are references to arrays, allowing for efficient memory usage.
Arrays are value types, while slices are reference types.
Arrays are initialized with a specific size, while slices can be created from existing arrays or other slices.
Slices provide additional func
Go routines are lightweight threads of execution that allow concurrent programming in Go.
Go routines are created using the 'go' keyword followed by a function call.
They are executed concurrently and independently of the main program.
Go routines communicate with each other using channels.
They are used to achieve concurrency and parallelism in Go programs.
Channels are used in Go to enable communication and synchronization between goroutines.
Channels are typed and can only send or receive values of that type.
They can be created using the built-in make() function.
The <- operator is used to send and receive values from channels.
Channels can be used to implement various synchronization patterns like blocking and non-blocking operations.
They are commonly used for concurrent
I applied via Naukri.com and was interviewed in Jan 2023. There were 3 interview rounds.
Goroutines are lightweight threads of execution in Go that allow for concurrent programming.
Goroutines are created using the 'go' keyword followed by a function call.
Concurrency is the ability to run multiple tasks simultaneously, while parallelism is the ability to run multiple tasks at the same time.
Goroutines can communicate with each other using channels.
Example: go func() { fmt.Println('Hello, world!') }()
Example:
Channels are a way for goroutines to communicate. Buffered channels have a capacity while unbuffered channels do not.
Unbuffered channels block until a sender and receiver are ready to communicate
Buffered channels allow for asynchronous communication up to a certain capacity
Channels are typed, meaning they can only send and receive values of a specific type
Array is a fixed-size collection of elements of the same type. Slice is a dynamic-size sequence of elements of the same type.
Arrays have a fixed size and are declared using square brackets, e.g. var arr [5]int
Slices are dynamic and are declared using the make() function, e.g. var s []int = make([]int, 5)
Slices can also be created using a slice literal, e.g. s := []int{1, 2, 3}
I have worked on various projects, including a web application for managing employee data.
I follow the Arrange-Act-Assert pattern for unit testing
I use testing frameworks like GoConvey and testify
I write test cases for both positive and negative scenarios
I use mocks and stubs to isolate dependencies
I aim for high code coverage to ensure thorough testing
Microservices are small, independent services while monolithic is a single, large application.
Microservices are loosely coupled and can be developed and deployed independently.
Monolithic applications are tightly coupled and require a complete redeployment for any changes.
Microservices allow for better scalability and fault tolerance.
Monolithic applications are easier to develop and test.
Examples of microservices includ...
Singleton is a creational design pattern that ensures a class has only one instance and provides a global point of access to it.
Singleton pattern restricts the instantiation of a class to one object.
It is useful when exactly one object is needed to coordinate actions across the system.
Singleton pattern can be implemented using lazy initialization or eager initialization.
Example: Database connection, Logger, Configurati...
I applied via Naukri.com and was interviewed in Mar 2021. There was 1 interview round.
Goroutines are lightweight threads of execution in Go.
Goroutines are functions that can run concurrently with other functions.
They are cheap to create and can be used to handle multiple tasks simultaneously.
They communicate with each other using channels.
Goroutines are managed by the Go runtime and can be scheduled on multiple processors.
Example: go func() { fmt.Println("Hello, world!") }()
Example: go func() { result :...
A slice is a dynamically-sized, flexible view of elements in an array in Go.
Slices are references to arrays, allowing for efficient manipulation of data.
They have a length and a capacity, with the length being the number of elements in the slice and the capacity being the maximum number of elements that the slice can hold.
Slices can be created using the make() function or by slicing an existing array or slice.
Example:
GOPATH is the workspace for Go projects, while GOROOT is the location where Go is installed.
GOPATH is used to store Go project files and dependencies.
GOROOT is the location where the Go standard library and tools are installed.
GOPATH can have multiple directories, while GOROOT is a single directory.
Example: GOPATH=/home/user/go, GOROOT=/usr/local/go
TCS
Accenture
Wipro
Cognizant