Buying for a Team? Gift This Course
Wishlisted Wishlist

Please confirm that you want to add Building Your First Application with Go to your Wishlist.

Add to Wishlist

Building Your First Application with Go

Get practical experience and learn basic skills while developing an application with Google Go
3.5 (12 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
234 students enrolled
Last updated 12/2014
English
$10 $85 88% off
3 days left at this price!
30-Day Money-Back Guarantee
Includes:
  • 3 hours on-demand video
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Have a coupon?
Description

Building the First Application with Google Go is your way into the world of software development. Go has a robust library and advanced techniques. This makes it a great language that can even be understood by people with no experience in programming.

Take a journey through the concepts presented by the Google Go language! Go is a language with no legacy, well suited for software developers, be it for beginners or experienced users.

The Google Go language presents fresh patterns of software development. You will learn about the core distinctive features of Go – goroutines and channels, which are used to design concurrent applications. You will gain familiarity with approaches of structuring application code, by breaking it into reusable components like functions, packages, and objects. Object-oriented programming; one of the central paradigms of modern software development, is also covered in this course. It offers the most popular and well-tested patterns for building brilliantly structured applications; the course finishes with creating a production-ready image manipulation program, which is built as a web application.

The course will help you to start building applications with Google Go right off the bat. Packed with examples, especially with a finished production-ready application from the final section, the course gives you the right vision of what software source code should look like.

About the Author

Rostyslav Dzinko is a software architect who has been working in the software development industry for more than six years. He was one of the first developers who started working with the Go language far earlier than the first official public release of Go 1.0 took place. Rostyslav uses the Go language daily and has successfully used it in production for more than two years, building a broad range of software from high-load web applications to command-line utilities. Rostyslav has a Master’s degree in Systems Engineering and will complete a PhD thesis in a year and a half.

Who is the target audience?
  • If you are a student or would like to dive into the world of software development using the Go language, then this video course is ideal for you.
Students Who Viewed This Course Also Viewed
What Will I Learn?
Find where to get the Go compiler and how to use supplied tools
Explore basic and complex data types and how Go manages main memory
Learn about the code execution control structure
Organize source code into reusable parts with functions and packages
Get to grips with the principles of object-oriented development and the specifics of their implementation in Google Go
Understand how concurrent applications work and how goroutines help you to easily implement concurrency
Schedule goroutines with a runtime scheduler
Build well-designed applications from the ground up
View Curriculum
Requirements
  • This course assumes that you have some basic knowledge of computer science.
  • Each video covers a whole feature of the language. It begins with a small amount of theory and ends with a working example, which you can run yourself.
Curriculum For This Course
Expand All 40 Lectures Collapse All 40 Lectures 02:52:55
+
First Application
5 Lectures 23:19

Getting the Go language compiler. Setting up the environment for developing and running applications.

Preview 04:34

Getting the very first application to work. It's useful to receive the first working result and understand the application structure.

"Hello, world!"
04:40

Mastering the standard go tool for processing the Golang source code: compilation, formatting, testing, and documentation.

Preview 04:54

Introducing standard input and output as the simplest way for users to interact with the application.

First Useful Application
05:00

Commenting and documenting the Go language source code in order to simplify the understanding of complex applications.

Commenting the Code
04:11
+
Basic and Complex Data Types
6 Lectures 29:52

Learn ways to store data in an application's main memory while switching between changing data and constant data.

Variables and Constants
06:28

Defining variables of numeric and textual data types. Introducing the boolean data type, which is a result of common operations.

Playing with Numbers and Strings
05:37

Using pointers instead of values. Learning the significance of pointers.

Pointers and Values
03:53

Using arrays and slices to store values. Avoiding a large number of variables for storing values.

Slices and Arrays
06:35

Using two-dimensional slices to solve practical tasks – representing matrices. Introducing n-dimensional slices.

Two-dimensional Slices
02:49

Using maps for practical tasks – serialization of objects and data caching.

Maps
04:30
+
Control Structures
5 Lectures 22:00

Adding the conditional execution of code blocks to an application. Even the simplest of applications require the conditional execution of code.

"if-else" – Understand Your Code to Make Decisions
05:08

Making code easier to read by replacing if-else with switch. Explaining cases when switch is better than if.

"switch" – Decisions Are Made Even Simpler
04:25

Adding repetitive task execution to the application. Explaining the significance of iterative algorithms.

"for" – Mastering Cycles
06:19

Learning error processing and error generation in Go.

Preview 03:21

Learning about the comma-ok notation and its role in code styling.

The "comma-ok" Notation
02:47
+
Structuring Code with Functions and Packages
5 Lectures 24:56

Function syntax, role of functions in code, and usage.

Functions
06:51

Usage of anonymous functions. Passing functions as values.

Anonymous Functions
04:53

Structuring code into packages. Separating the application logic.

Packages
05:11

Initializing packages. Order and purpose of the package init functions.

Preview 03:16

Deferred execution of functions and initialization and cleanup of resources.

Deferred Execution
04:45
+
Object-oriented Programming in Go
4 Lectures 17:43

Introducing encapsulation in Go. Structure definition and usage syntax.

Structures
06:26

Adding behavior to structures with methods. Private and public fields.

Behavior
04:08

Interface types as a way to glue application parts together.

Interfaces
04:35

Using the universal interface to pass any kind of data to a function.

Preview 02:34
+
Goroutines and Channels
5 Lectures 21:43

Learning how concurrency and parallelism can be added to an application written in Go.

Goroutines Lifecycle and Parallel Execution
06:52

Learning how data can be synchronized in concurrent Go applications.

Channels
04:26

Learning how buffered channels can be used in concurrent Go applications.

Preview 04:42

Solving the typical problem of data collection from different sources using goroutines and channels.

The "FanIn" Pattern
03:06

Solving the typical data distribution problem of different sources using goroutines and channels.

The "FanOut" Pattern
02:37
+
Building a Web Image Manipulation Program (WIMP), Part I – Web Application
5 Lectures 17:31

Creating a simple web server in Go. Learning the anatomy of a typical web application.

Running a Web Server in Go
03:35

Learning how a URL multiplexer solves a URL routing task.

URL Multiplexer and Query String Parameters
03:45

Learning how to add templates to an application – the standard html / template package.

Adding Templates
03:34

Learning how to cache templates in a web application in order to optimize performance.

Caching Templates
02:57

Catching runtime errors. Using the panic and recover functions to keep the application stable.

Errors, Panic, and Recover
03:40
+
Building a Web Image Manipulation Program (WIMP), Part II – Image Processing
5 Lectures 15:51

Learning how to process images. Implementing the color inversion algorithm.

Color Inversion
03:04

Learning how to load images into web applications.

Hooking Up an Image – Encoding and Decoding
03:04

Learning how to process images. Using the temporary memory storage.

Image Rotation
02:41

Learning how to improve the design and why we must do it.

Improving the Design
04:48

Analyzing the video course results and what the viewer should have learned.

Conclusion
02:14
About the Instructor
4.0 Average rating
3,624 Reviews
29,718 Students
311 Courses
Tech Knowledge in Motion

Packt has been committed to developer learning since 2004. A lot has changed in software since then - but Packt has remained responsive to these changes, continuing to look forward at the trends and tools defining the way we work and live. And how to put them to work.

With an extensive library of content - more than 4000 books and video courses -Packt's mission is to help developers stay relevant in a rapidly changing world. From new web frameworks and programming languages, to cutting edge data analytics, and DevOps, Packt takes software professionals in every field to what's important to them now.

From skills that will help you to develop and future proof your career to immediate solutions to every day tech challenges, Packt is a go-to resource to make you a better, smarter developer.

Packt Udemy courses continue this tradition, bringing you comprehensive yet concise video courses straight from the experts.



Report Abuse