As a software engineer (SWE) at Google, I built ground-up machine learning-adjacent data engineering systems on Maps, maintained the legacy backend of Classroom during its largest period of growth, attained sole ownership of Classroom’s experimentation infrastructure, influenced changes to company-wide performance expectations, and lead two project teams to repay Classroom’s 10-year documentation technical debt.

The cost of gaps in documentation accrues interest over time — relative to what percent of the underlying system is proprietary (i.e., not open source). In the worst case scenario — development velocity suffers, SWE hours (time spent on engineering projects) are inefficiently redirected to 1:1 mentoring/interruptions, onboarding is prolonged, morale suffers, and retention plummets — each a reality at Google. Considering the high cost of SWE hours, documentation tech debt costs millions to a company annually on a team with as few as 10 senior SWEs.

Working on an entirely proprietary codebase like Google’s makes documentation technical debt a uniquely challenging problem. 100% proprietary means that the available documentation is only as sufficient as what exists internally. That, combined with failure to reward documentation efforts as engineering work, leads to lack of incentive to prioritize such efforts. This contributes to a culture of secrecy in which information crucial to completing assigned work is hoarded by single points of failure, making it difficult to efficiently allocate SWE resources and nearly impossible to offer junior-level SWE job opportunities.

Unlike other forms of tech debt, documentation is infrastructure exclusively designed for humans, not a compiler, with the goal of making humans exponentially more productive. Understanding the problem at Google meant understanding how it impacted its employees. So I leveraged the connections I built through involvement in ERGs, community outreach, attending social events, and participating in team building exercises to have important conversations on the personal impact of the documentation gap. I shared my experiences authentically and listened to my colleagues’. The most profound thing I discovered wasn’t the unanimous consensus about the problem; it was how the problem caused crippling imposter syndrome in colleagues who felt too vulnerable to address it to leadership.

In 2020, Classroom, despite being a legacy codebase, was suddenly thrust into the spotlight as it became a utility for students accessing education remotely all over the world due to covid-19 lockdowns. MAU exploded. In Summer 2020, I jumped at the prestigious opportunity to switch teams from Maps data engineering to Classroom backend.

On Classroom, I influenced prioritization of two adjacent projects — one at the org level, the other on the backend team — and led the engineering efforts for each 6-person team.

At the org-level, I designed the hierarchical taxonomy for the content’s cumulative curriculum, defined technical nomenclature, tracked down cryptic information from senior SWEs, documented processes, instructed leadership on collection of metrics, and created standards for writing the content tailored to a very specific audience: newly hired junior SWEs.

I led the engineering efforts at the org-level for 4 months and delivered the finished documentation ahead of the onboarding of 15 new team members in March 2022, the majority being new hire junior SWEs.

Simultaneously, I led the effort to document the backend team’s codebase in the form of weekly presentations that we recorded and shared org-wide. I scoped the work, developed the curriculum, led meetings to mentor leadership on technical writing best practices, collaboratively implemented the content, created diagrams to represent abstract server components, defined backend nomenclature, designed plans for long-term maintenance, and was responsible for reviewing content contributions from my team members.

In conjunction, I developed a management approach to scale mentoring new SWEs and improve productivity. I restructured open-ended twice weekly team meetings to be agenda-driven Q&A sessions where team members scheduled a question in a shared doc ahead of time to be answered by the rest of the team collaboratively. When first implementing, I was in charge of running the meetings and assigning a scribe. The meetings were widely popular, efficient, and eliminated costly reliance on 1:1 mentoring.

At my direction, we collected metrics in the form of surveys and feedback. Documentation seeks to improve human productivity, a metric which cannot be isolated independently in lines of code submitted. Aside from the number of clicks and minutes accessed on the docs (in addition to attendance numbers during presentations), we focused on analyzing subjective feedback. One example, we compared onboarding experiences of new hires to that of existing SWEs who had joined prior to the documentation effort. Objective metrics were used to compare length of onboarding of the two groups. That is, the length of time it took since joining the team for a SWE to acquire the skills and knowledge necessary to confidently and independently work on assigned projects.

Our goal was to reduce onboarding time, maintain development velocity for existing SWEs simultaneously, and improve employee morale.

The impact exceeded expectations. Onboarding for newly hired junior SWEs decreased from up to 6 months to 1–2 weeks. Employee morale skyrocketed as engineers felt confident in their ability to work independently and effectively communicate when asking a question. Development velocity not only was maintained, but increased. Reliance on 1:1 mentoring decreased. For the first time, retention improved.

Annually, the impact of solving documentation technical debt within one org resulted in millions saved for an entire company.

“Culture is what you reward” (-unknown), so I influenced a company-wide paradigm shift on how documentation is rewarded. My legacy was seeing a 3-year initiative come to fruition: documentation becoming an explicit performance expectation for all SWEs company-wide.

At Google, I developed a systematic, empathetic approach to leading innovative solutions for long-term maintenance of legacy software, influencing decision making, and connecting with and inspiring colleagues. I helped Google achieve its goals by furthering the productivity of others, coming up with the big ideas, leading others in the execution of those ideas, taking ownership of challenging infrastructure, and improving communication between stakeholders and SWEs. I hope to bring those skills and experiences to my next opportunity.

A couple days after my 28th birthday, I received my first full-time offer since completing my Master of Science in Computer Science. The position was for a 3-month internship at Floreo, a Washington, D.C.-based startup creating mobile virtual reality applications that help people with autism.

Although my job title was only “Software Engineer Intern,” my responsibility was that of “Lead Android Developer.” I was tasked with building the entire Android mobile application, from scratch! When I started my internship February 1, 2018, the application had been built for iOS mobile, which paired wirelessly with an iPad so that the VR experience could be monitored. From the iOS mobile codebase, I had to translate the equivalent code for Android. The end goal was to have a fully functioning Android app for mobile that loads the VR graphics and pairs wirelessly with an iPad monitor device.

Mission accomplished. Here’s how I did it:

Model — View — Controller Architecture

Model-View-Controller (MVP) is an architectural pattern for structuring code within a program. MVP is the separation of code components: the model, which is the data that your app uses, is separated from the view, which is the code that designs the app’s UI, and both of which are separated from the controller, which is the code that manipulates the UI.

I followed the MVP conventions while designing the architecture for the project.

Models

The models are defined as regular Java classes. Each individual class has a unique name and defines a new type of data model. The purpose of a model class is to provide a template for constructing data and for storing that data in main memory.

As shown in the project navigator image above, I encapsulated the model data files within a directory named “model”. Each subdirectory contains one or more Java files used for a particular purpose. For instance, the “loginResponse” directory contains model Java classes used to form the response data returned by the server after making a login network request.

Views

The views are made up of XML layout files, which define how the UI should look. A view contains the code for designing the actual appearance that the user will see on the screen. In general, each individual XML layout file represents one distinct screen that will appear on the user’s device. The XML file contains references to any images (e.g., .png files), buttons, formatting, styles, colors, and text for designing that particular screen.

Controllers

A controller is a special type of Java class, called an Activity class, which corresponds to an individual XML layout file. Within the code for every Android application, there’s a special file called the AndroidManifest which provides a list of all the app’s Activity classes.

In the AndroidManifest, I declared the LandingPageActivity as the activity whose code will be executed first whenever the app is launched. As you can see from the line of code at the bottom, the activity class specifies which View to show on the UI. It also contains all the logic for what instructions to do while the landing page is being shown on the device, as well as code for navigating to the next activity class once this one is complete.

UI Navigation

My goal for the app’s UI navigation was to mimic the appearance and flow of the Floreo iOS app’s authentication, login, game play, and pairing.

Authentication

1. The user launches the app and sees the LandingPageActivity.
2. After 2 seconds, the app navigates to the RegistrationCheckActivity.
3. The RegistrationCheckActivity waits for the user to input their email and tap the ‘Next’ button. Behind the scenes, a network request is initiated to determine whether the user’s email has been beta-approved.
4. If so, the app navigates to the CreateUserAccountActivity.
5. Otherwise, the app navigates to the RegistrationRequestActivity.

Login

There are a few paths the app can take to navigate to the LoginActivity from the RegistrationCheckActivity.

1. First, if the user accidentally initiates a registration check network request but the user already has an account, then…
2. the app will navigate to the LoginActivity.
3. Second, after a beta-approved user…
4. creates their account,
5. the app will navigate to the LoginActivity.
6. Last, is when a registered user simply taps the ‘Sign in’ link on the RegistrationCheckActivity.
7. The user enters their login credentials and taps the ‘Login’ button, which initiates the login network request.

Game Play & Pairing

1. After the user successfully logs in, the app navigates from the LoginActivity to the PlayerManagementActivity, which displays the list of players to the user.
2. The UI list is populated with the list of players retrieved from the get players network request.
3. The list gets populated with data defined by the model Player java class.
4. When the user taps on a player in the UI list,
5. the app navigates to the WaitForMonitorActivity, which shows a progress bar as, behind the scenes, network requests are made to pair the device to a monitor iPad.

Persisting Data

Shared Preferences

To persist data between a user’s sessions, I used Android’s SharedPreferences library. SharedPreferences allows data to be saved to a file on the user’s device as a key-value store, which can be read or written to during future launches launches of the app.

1. The user first launches the app, enters their login credentials, and taps ‘Login’.
2. If successful, the encryption function is called, passing in the user’s login credentials.
3. The encryption function returns encrypted values for the login credentials.
4. Next, a function is called to retrieve the device ID.
5. Last, a function is called to persist the encrypted login credentials, which stores appended versions of the device ID string as they keys for the user’s encrypted login and password.

When the user launches the app in the future and tries to navigate to the LoginActivity, the device first checks for the SharedPreferences file on the device. If it exists, the app uses the device ID to look-up and retrieve each login credential, decrypts them, and automatically logs in the user.

Non-UI Operations

Util Classes

To keep with best programming practices, I cleaned up the code. First, I refactored methods in my activity classes that didn’t need to be declared within the context of an activity. Second, I created a separate java class, which I called a Util class.

A Util class it a class that is not an Android activity. This means that the class doesn’t correspond to a UI XML layout file, nor does it serve as a template for instantiating objects. A Util class is simply a class that contains a series of functions, each of which performs some task.

After creating Util.java, I then moved the encrypt(), getDeviceId(), and persistData() functions into the Util class.

The benefit of doing this is that these functions are now available to all the other classes and activities. Instead of redefining these functions in each activity, I can define them once in Util.java, and then reuse them as needed throughout the rest of the project.

Networking

A majority of time during the course of my internship was writing the code for performing network requests and handling the responses from the server. Here are the types of requests that the app makes:
- Login,
- Refresh login session,
- Check account status,
- Create account,
- Get players,
- Post ticket for device pairing,
- Claim ticket for device pairing, and
- Report events.

The goal of the networking code is efficiency. The code must take the device hardware into account by optimizing for concurrency. To accomplish this, my networking code evolved over a series of approaches.

Naive Approach 1: Subclass AsyncTask

My first approach was to subclass AsyncTask for making the network requests. AsyncTask is used to perform non-UI operations in a background thread. I wrote out the entire code for making the network requests, handling the server response, parsing the JSON, and providing the results to the Activity that initiated the request.

Naive Approach 2: Networking Library and Subclass AsyncTask

My second approach was to use a third party libraries for making network requests and parsing the JSON responses. I used the Retrofit 2.0 library for kicking off the requests and handling the callbacks for the responses. I also used the Gson converter library for parsing the JSON and turning the response into model data objects.

I accomplished this by creating a Floreo API (FLAPI) class that defines the method signatures for the entire suite of methods that kick of network requests. Each of those methods was then implemented in the AsyncTask subclass.

Problem: Memory Leaks & Unused Resources

When using AsyncTask for handling background operations, the AsyncTask stores a reference to the activity class that initiated it. By storing a reference to an activity class, my code was vulnerable to potential problems: memory leaks and unused memory resources.

As an example:

1. The user navigates to the LoginActivity, and so the device stores the activity instance in main memory.
2. When the user enters their credentials and taps the Login button, an AsyncTask is created. A background thread is initiated for performing the login network request and the AsyncTask instance is stored in main memory. The AsyncTask holds a reference to the calling LoginActivity instance.
3. Suppose a configuration change occurs, such as when the user rotates the device from portrait to landscape. Then, the LoginActivity instance is destroyed in main memory.
4. The configuration change causes a new LoginActivity instance to be created. Suppose the AsyncTask has not yet completed. This scenario leads to a memory leak since the AsyncTask still has a reference to the original, nonexistent LoginActivity instance, which causes the app to crash.
5. From configuration change, if the user were to tap on the Login button again, another AsyncTask would be created and stored in memory, which means the app is using more memory resources than necessary.

Solution: RxJava and RxAndroid Libraries

RxJava is a reactive library that follows the functional programming paradigm. Instead of subclassing AsyncTask or writing messy threading code, RxJava simplifies the process of asynchronous tasks without blocking the main thread. The building blocks of RxJava are Observables and Subscribers.

The Observable emits data asynchronously and the Subscriber consumes that data. The subscribeOn() method instructs the Observable as to which thread to emit the data stream on. Upon completion, the observeOn() method emits the data to the specified thread, which in my case, is the main UI thread.

Design Patterns

Singleton

Throughout a user’s entire experience from launch to close, the app relies on various pieces data, such as the login data, the session data, and the user’s device ID.

At first, any time an activity or thread needed to access such data, it would call a Util function. For instance, each time the app needed to access session data, it would retrieve the data from Shared Preferences, then call a decryption function, and then pass the decrypted credentials to the caller. This session data is required for almost every networking request that the app makes. This means that the code was not optimized since it was repeatedly performing the same operations.

Since the data is used throughout the entire app execution, and since that data only needs to be initialized once, I implemented the Singleton pattern. The operations to set the values are called once and then are only read accessible. As a result, after the data is instantiated, its values remain consistent throughout the app’s execution and can safely be read by any thread.

UI Adapter

After the user successfully logs in, the app performs the get players network request and navigates the user to the FLPlayerManagementActivity. The goal of the FLPlayerManagementActivity is to show the list of players.

To accomplish this, I implemented an adapter that abstracts the process of converting model Player objects into views that will be populated in the UI. The Adapter Pattern provides a uniform interface for incompatible class types.

In my layout directory, I define two layout files: a layout file that corresponds to the FLPlayerManagementActivity which contains a ListView element and a list-item layout file that defines the layout for the individual items that will populate the ListView.

Here’s how it works:

After the list of players is retrieved from the network request, that list gets passed into the constructor for creating model PlayerAdapter data. PlayerAdapter subclasses BaseAdapter, which is an Android library used to populate a ListView with list-items by adapting a base list-item to the specifications defined in the list-item XML file.

Within the PlayerAdapter class, I defined a static class ViewHolder. The getView() method is called for each list-item when the list is currently in the foreground of the user’s screen. Within the getView() method, a ViewHolder object is declared and used as a placeholder. The ViewHolder then converts (or “adapts”) each base Player instance into an actual list-item object.

After the list becomes visible to the user, the activity waits for the user to select a player by tapping on one of the list-items. The super BaseAdapter class provides the methods needed to which which player list-item the user selects the ListView.

Concurrency Optimization

Although all the network requests were being processed on background threads, there was still room for improvement. A lot of the threading code was pretty messy, in that it used Handlers and Runnables.

Therefore, I focused a great deal of attention into analyzing and categorizing the types of network requests. My goals were to optimize for concurrency, reduce memory usage, and improve the user’s experience.

Threads in Android

The main thread, also known as the UI thread, executes all the activity code. It’s used throughout the lifetime of the app from launch to close.

The background threads are generally short-lived threads of execution used for non-UI purposes.

The developer is responsible for explicitly scheduling tasks on background threads. Otherwise, by default, the code operates on the UI thread. In comparison to the main thread, the lifetime of a background thread is usually shorter — it will be used to perform a task such as a network request and will terminate when the task completes.

Categorizing the Network Requests

Based on the, I categorized the network requests into three distinct types:

1. Requests whose responses trigger changes in the UI
2. Requests whose responses trigger a subsequent request, and
3. Requests whose responses are irrelevant.

1 — Requests that Trigger UI Changes

The login, get players, and get ticket requests fall into the first category. After the user logs in, the login network request is performed and if the response is successful, the app navigates to the FLPlayerManagementActivity and renders the corresponding XML layout.

Of the three categories, this type of request requires the most communication between the background and main threads. For this reason, I implemented subscribers and observables from RxJava and RxAndroid libraries to kick off the requests, convert the responses into model data, and then emit that data to the main thread as soon as its available.

2 — Requests that Trigger Subsequent Requests

The post ticket request falls into the second category. From the FLPlayerManagementActivity, when the user taps on a player list-item, the app kicks off a post ticket request in a background thread. As soon as that thread receives a response from the server, it kicks off a get ticket request.

Since the response for post ticket does not need to be provided to the UI thread, I used Android’s ThreadExecutor library. The post ticket request is made as a Retrofit 2.0 Call, which enqueues the Call. The response is then sent to the background thread and is never returned to the UI thread.

I used ThreadExecutor as a clean alternative to Handlers and Runnables. This allowed me to abstract the details of the background threading from the activity code.

3 — Requests without Changes

When the user selects a player from the ListView in FLPlayerManagementActivity, the app navigates to the UnityPlayerActivity and attempts to connect to the Unity engine. At this point, the app renders the VR graphics.

Because of the demands of the VR graphics, the app needs to periodically collect device data such as frame rate and battery percentage. As soon as the VR graphics render, I needed to collect the device data and send it to the server in the form of a report events network request. Because the server does not provide any meaningful data as a result of the request, and because the request does not lead to changes in the UI, the report events request falls into the third category of network requests.

I chose to use Android’s IntentService library for handling report events requests. A Service in Android is a component used for long-running, non-UI background tasks. I implemented a Started Service since, once initiated, the background operations would continue processing until the user closes the app. I set up my IntentService using a timer. After every 60 seconds, the service collects the device data and then makes a report events request to send that data to the server.

Cross-Platform Communication

In order to render the VR graphics, I had to learn how to make my Android app communicate with the Unity engine.

The first step was running Unity builds. Each update to the code required running a new build in Unity for Android. I added in the logic to the build scripts so that each build was equipped to support both iOS and Android. After the build script would complete, it would generate a new Android project that contained all the code I wrote and all the Unity code it needed to support it.

In Android, I had to add libraries to the Android Manifest file so that it could support the VR graphics. Then, within a series of Java files and Unity files, I set up methods that established the communication channel between the two different platforms. The cross-platform communication code contained the following: Java files containing methods called from Android, Java files containing methods called from Unity, and C# files in the Unity project that call the Android code.

When the user navigates to the UnityPlayerActivity and successfully pairs to the iPad monitor, Android calls to Unity to connect to the engine. Once connected, the graphics render and the user is able to experience a new world in VR.

More where this came from

This story is published in Noteworthy, where thousands come every day to learn about the people & ideas shaping the products we love.

Follow our publication to see more product & design stories featured by the Journal team.

The objective of this article is to make learning programming accessible to anyone.

Frequently Asked Questions

As a mentor, I am constantly asked the following:

“Which programming language should I learn if I’m new?”

“Which programming language is most in-demand for jobs?”

“What’s the most popular programming language?”

Top Programming Languages

If you’re looking for an official ranking of the top programming languages, you can find it here: IEEE Spectrum top programming languages

That list is great for checking whether a particular programming language is in use today. However, if you’re new to programming, I don’t recommend choosing a language solely based on a list.

How to choose a programming language

Computer science is an entirely cumulative field of study. That means, each successive topic builds off prior topics.

If you have previously attempted to learn programming (or any STEM field) in school, tried your best, but failed — you weren’t the problem. A good professor of any cumulative subject carefully curates the curriculum. Provided that each student has sufficiently prepared and satisfied the prerequisites, the expectations for the students’ prior knowledge should be clear. A good professor understands the expectations and assumes no knowledge beyond that scope. Anything outside of the expectations must be taught. Each topic in the curriculum is ordered sequentially, respective to the other topics.

When a subject is cumulative, meticulous attention must be paid when designing a course curriculum or learning path. With that said, don’t choose a language for its ranking; choose a language for which you have a complete learning path that makes no assumptions about prior knowledge.

A few words of advice

Before you begin learning how to code, it’s important to reflect on the point I made above: everything in computer science is cumulative.

I like to reiterate this because the biggest mistake you can make as an aspiring programmer is giving up because you don’t think you’re smart enough to learn programming. Learning to code has nothing to do with your intelligence. Yes, it’s difficult to learn programming, not because of who you are, but because there are a lot of topics to learn.

First rule, accept that the following scenario is going to happen: you’re introduced to a new topic that makes absolutely no sense to you.

That scenario is going to happen over and over again. How you handle that situation, each time it happens, is the only factor that will determine your success.

If the current topic you’re learning doesn’t make sense to you, stay where you are. Do not proceed to the next topic. To reiterate, the topics are cumulative. Skipping ahead is like trying to attach a roof to a house that lacks a frame, walls, and a foundation.

I find myself in this situation all the time. I often have to rewatch the same lecture of a video tutorial several times for me to grasp what I’m learning. Don’t get discouraged if you find yourself in my shoes.

If the tutorial (or book) you’re using didn’t sufficiently explain the topic, you’re going to have to find other resources that work for you. There’s no excuse for giving up just because your tutorial’s coverage of a topic didn’t work for you. You can find just about anything you’re looking to learn for free on YouTube. Figure out what to search for (e.g., [the topic] in [your programming language] + any other helpful keywords).

If you’re searching on YouTube for educational tutorials, check the stats first. Take a quick look at the rating and/or the view count. If you’re still unsure if a video is worth your time, read some of the comments to gage others’ opinions.

A lot of topics aren’t going to make sense the first time around. So, refrain from the negative self-thoughts.

The goal is to be conscious of your comprehension as you’re learning. As you progress through the learning path, you need to self-reflect. For each topic you cover, ask yourself questions such as:

• “Does this topic make sense to me?”
• “Was there any new terminology? If so, was a formal definition provided for each new term?”
• “Were there any new skills? Do I understand how each new skill is used in application? Can I demonstrate my understanding of this skill by solving practice problems?”
• “Will I remember what I just learned tomorrow? And the day after? If not, how am I going to commit it to memory?”

One last piece of advice: never underestimate the power of memorization. Memorization is a totally underutilized approach in learning. Yes, comprehension of a topic is the ultimate goal. However, comprehension may take time. If you are really struggling to grasp a topic, break down the topic and memorize the important terms. If you can’t comprehend how something works, your immediate goal should be memorization. If you need tips on how to tackle memorization, consider using the study card technique. You can read more about how I use this technique in my Interview Prep document.

1 — Computer Science Fundamentals

The first step is learning computer science fundamentals, which I cover in my article: Intro to Computer Science Terminology. This article is written specifically with my audience in mind — everyone. I intentionally created this so that it is easy to understand for anyone with no background in computers.

The concepts covered in the article are predominantly definitional. You can casually read through the article, and that’s fine it that suffices for you. I recommend committing these terms to memory. Approach each term as though you’re in school and you need to be able to recall each term’s definition for an exam. You don’t have to commit yourself so thoroughly if you don’t want to. However, the more of these concepts that you can commit to memory, the easier it will be to understand later topics.

2 — Propositional Logic (optional)

No, you don’t have to be strong in math to be a programmer. Math skills can be helpful, but they’re not necessary.

If you’re insecure about your math abilities, I recommend learning propositional logic. The principles covered in propositional logic are the building blocks of programming.

You can learn propositional logic from this YouTube tutorial: Basic Concepts in Propositional Logic.

3 — Java Programming

After you’ve learned the basics of computer science, you’ll be ready to learn a programming language.

I have put a lot of thought and effort into designing a path that is suitable for everyone, regardless of their background. I chose Java for this learning path because Java is the language that I am most experienced in.

Java is one of the most in-demand programming languages. It’s classified as an object-oriented programming language (you’ll learn what this means later on) and it’s used to make desktop, web, and mobile applications.

If you prefer learning from a book, I recommend the following: Head First Java.

If you’re looking for a video tutorial, I recommend watching videos #1–19, 31–33, 88, and 93 in the Java YouTube tutorial by Derek Banas: Java Video Tutorial.

The first video in the YouTube tutorial will direct you to download a computer program called Eclipse. Eclipse is an Integrated Development Environment (IDE). You can think of an IDE as a fancy term for a word editor that is made for programmers. It’s just a computer application that provides a text editor for programming, along with other tools for running your programs. Here’s the link to Derek Banas’s YouTube video on how to download Eclipse: Install Eclipse for Java.

4 — Algorithms and Data Structures

An algorithm is a set of instructions (or steps) for performing a specific task, where each step must be clearly defined, capable of being executed, and finite (meaning, it doesn’t continue executing infinitely).

A data structure is a way of organizing data in memory.

Algorithms and data structures are two of the most challenging topics of programming. You don’t need to learn algorithms for basic competency in programming. However, if you aspire to work as a software engineer at a reputable tech company, you will be expected to demonstrate comprehension of algorithms and data structures during the interviews.

On a personal note, the tutorial below is what took my algorithm skills from novice to expert: Udemy tutorial on Algorithms and Data Structures. I’ve purchased a lot of tutorials on algorithms. This was by far the most comprehensive one that I’ve come across. Whether you want to learn algorithms and data structures or prepare for technical interviews, this tutorial is your best bet for success.

Note: the course is expensive, but essential. I was able to get in contact with the instructor, and she has generously offered a coupon code which reduces the cost from $50 to $10. The coupon code will be applied automatically when you click the link.

I recommend using the following tutorial alongside the Udemy tutorial: VisuAlgo. VisuAlgo is a free resource that shows visuals of how the values input into an algorithm change throughout its execution.

5— Android development

Android development is, in my opinion, one of the most fun applications of Java programming. Android apps are predominantly programmed in Java, so once you learn Java, you’re ready to learn Android.

Here is the best free video tutorial to start learning Android: Udacity-Android Development for Beginners.

After you complete the Udacity course above, you have a couple options where to go from there. There should be an extension to the above course that is taught by the same group of Google employees. The additional lectures should become visible once you get through the course (if you can’t find it, search for it on Udacity). That is a good option, especially since it’s free.

However, if you are willing to spend money on an outstanding book, I highly recommend the following: Head First Android Development: A Brain-Friendly Guide. This book gives detailed explanations and helpful visuals to really help you learn the underlying concepts of Android. Each chapter walks you through an example application. Everything is explained thoroughly, using words and diagrams that anyone can understand.

Helpful Resources

Stack Overflow is a website where programmers can get free help with their code. If you get stuck and want to ask a question, search for it first. If you can’t find your question, create an account and post the question yourself!

There are a ton of educational sites where you can find programming tutorials. Some of my favorites are Codecademy, Udemy, Udacity, Team Treehouse, and Khan Academy.

“I Want to Learn Programming but I Don’t Know where to Start” was originally published in codeburst on Medium, where people are continuing the conversation by highlighting and responding to this story.

A complex definition: Computer Science is the study of information technology, processes, and their interactions with the world.

A simple definition: Computer Science is the study of using computers to solve problems.

Computer Basics

A computer is a machine that performs computations based on instructions.

A computer is made up of two components:

• hardware
• software

Hardware consists of the physical components of your computer. If you can kick it, punch it, or pick it up to throw it, it’s hardware.

Software, on the other hand, is not a physical component. Software consists of a set of instructions for the hardware. These instructions are typically saved in files on your computer. The instructions aren’t in English or any other spoken language; they are in a special type of language, called a programming language.

To sum it up, hardware is anything you can physically touch. Software provides the instructions that tell the hardware what to do.

A program is a synonym for a piece of software, or an application. In essence, it’s a file saved on your computer, written in a programming language, that contains instructions to tell the computer what to do when the program is launched.

Code is a synonym for the “instructions” within a file. It’s also synonymous with software. “Code” is just a bunch of words and punctuation symbols within a computer program, written in a programming language.

Computer Hardware

To learn programming, you must first learn the basics of computer hardware.

The different components of computer hardware each serve various purposes.

There are 6 main components that make up a computer’s hardware:

• The Central Processing Unit (CPU)
• Main Memory
• Secondary Storage
• Input/Output Devices (I/O Devices)
• Network
• Bus

The CPU is often called the “brain” of the computer. It is responsible for executing instructions, such as the code in a program.

The Main Memory, also referred to as “Random Access Memory” (RAM), is used to store: 1) the code from your programs and 2) the data that the code operates on while the program is actively running. When you open an application such as Microsoft Word on your computer, the code to run Microsoft Word gets loaded into main memory.

Secondary Storage stores your programs and data when they are not actively being used.

I/O Devices allow people to interact with the computer. I/O Devices allow people to input data into the computer (keyboard, mouse, microphone) or output data to the user (monitor, printer, speakers).

The Bus is a group of wires that connect the different hardware components. These wires allow data to be passed between the different hardware components. For instance, when you run a program on your computer, the bus sends the data (including the actual code of the program) stored in Secondary Storage to the Main Memory.

A Network allows your computer to connect to other computers around the world. Networks allow you to send and receive data from other computers, such as an email to or from a friend.

Programming Terminology — Synonyms

In general terms, you can think of each of the following three groupings of words as synonyms. While each can denote something that varies slightly, for your introductory understanding, you can think of the following as being equivalent:

1. “code” = “computer instructions” = “software” = “program” = “app” = “application”
2. “coding” = “programming” = “software development” = “software engineering”
3. “programmer” = “coder” = “software developer” = “web developer” = “software engineer”

Machine Language vs. Programming Language

Computers and humans represent and understand information in different formats.

Anytime you save data (such as a Word document) to you computer, the computer stores all the characters you type in a special format, called binary, also known as machine language.

Binary is a language made up of combinations of 0s and 1s. Each character on your keyboard has a unique binary representation that distinguishes the character from the rest.

A character can be a letter, numerical digit, punctuation sign, symbol, space, next line return, tab, etc. Each character has a unique numerical code that distinguishes it from others. You can find out the numerical code (ASCII code) for each character by looking it up in an ASCII table, such as here: https://www.cs.cmu.edu/~pattis/15-1XX/common/handouts/ascii.html

Notice that the character ‘A’ is separately distinguished from ‘a’.

‘A’ has the numerical code: 65

‘a’ has the numerical code: 97

This means, anytime the character ‘a’ appears in your document, your computer saves the data for it in the binary equivalent to the value 97.

Note that 97 is a human-readable format, which is called “Decimal” format. “Decimal” is the name of the format for numerical values represented in base-10, meaning that the digits 0–9 are used to form the values.

“Binary” format implies that the numerical values are represented in base-2, meaning that the digits 0 and 1 are used to form the values. That may sound pretty abstract, but you can surprisingly convert a decimal number to binary (and binary to decimal) using mathematical formulas. There’s no need to do this — this is just for your information. If you actually wanted to get the binary representation of a decimal number, you can use a calculator, such as: https://codebeautify.org/decimal-binary-converter

When you save your Word document and close your Word application, your computer actually saves your document in 0s and 1s. People designed computers to be efficiently used by humans. Since binary language isn’t an efficient means of communication for humans, it would not make sense for humans to see their Word documents in binary format. For that reason, when you later reopen your document, it will be translated from binary format and back into English (or whichever language you used).

Binary (“machine language”) is referred to as a “low-level language.” It’s considered to be “low-level” because it is a language that machines understand.

Programmers type their programs in a programming language.

A programming language is referred to as a “high-level language” since it is a language that humans can read and understand.

Just like English, a programming language also has its own set of rules, or syntax. It also contains a set of defined words called keywords (or “reserved words”) that have a specific meaning when used in a program.

Programming Paradigms

Just as there are many different spoken languages that humans communicate in, there are also many different programming languages programmers use to create programs.

A programmer who knows several different programming languages will select the most appropriate programming language to use in each particular circumstance. For instance, there are programming languages that are more suitable for web development (making websites) and there are others that are more suitable for mobile development (making smartphone apps).

In addition to specifics such as the type of development, at a more granular level, programming languages are classified into different programming paradigms.

Here’s a simple definition for the word “paradigm.”

A paradigm is a way of thinking or a way of doing something. A paradigm is a mindset.

A programming paradigm is a way of classifying a programming language based on the style or methodology of programming.

Here are a few common types of programming paradigms:

• The functional programming paradigm
• The procedural programming paradigm
• The imperative programming paradigm
• The object-oriented programming paradigm

As an example, Java and C are examples of programming languages. The Java programming language is an example of an object-oriented programming language. The C programming language is an example of a procedural programming language.

For now, you don’t need to know what it means for a programming language to be classified as object-oriented or procedural. However, it just helps to understand that there are different classifications for the various programming languages.

Writing and Saving Your Code

The first step in the software process involves programming, which simply means to write code. A programmer writes code to create a program. A program is simply an application that does something, or achieves some goal, when the user of the application launches it. As the programmer, your goal is determine what you want your code to do, and to write the code.

When you want to write an essay, you use a computer application such as Word or any text editor. You simply open the text editor application, create a file, type in some text, and save your document in the desired file format, such as .docx or .pdf.

The process of writing code is similar.

You can write your code using a text editor or an Integrated Development Environment (IDE). An IDE is a computer application that contains all the tools you need to program, such as a text editor, a compiler, a runtime environment, and a debugger.

A debugger is a tool that programmers use to find mistakes in their code, called bugs. For instance, A bug may either prevent a program from compiling, prevent a program executing (running), or may cause a program to produce incorrect values. Learning how to debug a program is a skill that you will develop over the course of your professional life.

After you create your program, you must save your code within a file, called a source file. A source file is simply a file that contains source code, which is your program’s code. Saving your code within a source file requires naming the file with a root name and an extension. The root name is the unique name you choose to give your file, which is comprised of the characters appearing to the left of the dot (.) of your file name, and the extension is what appears to the right of the dot. You give the source file the extension expected according to the programming language of your source code. For instance, the extension .java is used for source files written in Java, whereas the extension .c is used for source files written in C.

Compiling and Running Your Code

Suppose you have written a program in the C programming language and saved your program as myprogram.c. Next, you will want to run your code to see if your program does what you had intended it to do.

Before you can run (“execute”) your code, your source file needs to be translated from C (the higher-level language) to a binary (the lower-level language) executable file. An executable file (or, “executable”) is a file that contains the binary translation of your code and, when launched, it will run (“execute”) your program. This translation process is called Compilation.

Compiling is the process of translating source code within a source file from higher-level language into lower-level language, and then creating and saving that translated code in an executable file.

A compiler is a computer program used for compiling your code. It is a common tool included in an IDE. When using an IDE, the IDE may handle running the compiler program for you when you run your code. When you are not using an IDE, you will need to launch the compiler and specify the source file you would like it to compile for you.

If your program contains no bugs within the code, it will produce the executable, and the compilation process successfully completes. However, if your program contains one or more bugs, it may cause an error, preventing the compiler from producing the executable. If the compiler produces an error, you will need to go back through your code to debug it and correct the mistake(s).

Once you have successfully compiled your program, you can run (“launch” or “execute”) the executable, and your computer will execute the instructions of your program.

Note: a lot of these topics are covered in the following introductory textbook to C programming: The Art and Science of C, by Eric Roberts

Intro to Computer Science Terminology was originally published in codeburst on Medium, where people are continuing the conversation by highlighting and responding to this story.

In simple terms, what is blockchain?

Blockchain is a decentralized, distributed ledger of transactions (blocks), each of which holds a link to the previous block. Hence, the name “blockchain” refers to the linking or chaining of blocks.

Centralized Transactions Economy

This TED Talks presented by Bettina Warburg on blockchain examines a brief history of the role uncertainty plays when making transactions. For instance, when purchasing a product, both the buyer and seller need assurances: that the other person is who she claims to be, that the product is as advertised, that the buyer compensates the seller, that the seller gives the buyer the product, and that there is recourse if any of the terms of the transaction are not met. Currently, our economy relies on institutions — banks, governments, and corporations — as central authorities to reduce uncertainty in transactions.

Centralized Internet

Our current model of the Internet is also a centralized system. Data is stored on web servers. When we want to receive data on the Internet, such as view a website or download a file, our web browser sends a request to the web server that hosts that data, and the web server responds to that request by providing the requested data. A centralized Internet is not fault tolerant: if a server goes down, the entire system is affected.

In complex terms, what is blockchain?

Blockchain is a cryptographically secure database containing an immutable history of transactions where each transaction contains a digital signature. A block’s digital signature is generated using a cryptographic hash function that links the new block to the previous block. In essence, it’s just a massive ledger of transaction history.

Blockchain from a programmer’s perspective

The following code snippets are based on this YouTube tutorial by YouTuber Ivan on Tech on how to code a simple blockchain in Java.

A Block object would store three fields: the previous block’s hash value, a string array containing the list of transactions, and its own hash value. A new block is created by passing in the previous block’s hash value and the array of transactions to the Block constructor. The block’s hash value is generated by passing in the previous hash value and the transactions array’s hash into the hash code function. The blockchain is immutable in that once constructed, its fields are encapsulated in the block and can only be accessed through getter methods.

A blockchain is simply represented as an ArrayList of blocks. The first block in the blockchain is called the genesis block. To construct the genesis block, we simply pass in 0 as the previous hash value along with the corresponding array of transactions. After constructing the genesis block, we add it to the blockchain. Then, the second block is constructed using the hash value of the genesis block and the transaction array.

Running this program produces the following output:

The idea is, a transaction cannot be altered once it has been created. Changing even just one character, such changing the genesis transaction from 10 coins to 100 coins, would generate entirely different output from the hash code function.

Decentralization through Blockchain

The transaction history of a blockchain is stored across a peer-to-peer network of personal computers. These personal computers both utilize and facilitate the blockchain system, and no individual person or entity owns it. This makes the blockchain network both decentralized and distributed. Unlike in the client-server model, the blockchain does not have a single point of failure. Rather than a single entity providing assurances, transactions are validated by consensus across the network.

Big companies are getting involved

Blockchain technology has the potential to solve problems in the transactional economy. So it’s no surprise that blockchain has captured the attention of major banks and companies. Microsoft is one of many companies getting involved in the Decentralized Identity Foundation (DIF). The project’s mission is to solve problems related to online identity by using blockchain technology. This is just one of many examples. Currently, many companies, including IBM and Microsoft, are looking to hire blockchain developers. Read this article to see a list of other companies getting involved in blockchain technology.

Start Learning

Check out https://blockchaintrainingalliance.com/ to jumpstart your blockchain education.

Why Programmers Need to be Learning about Blockchain was originally published in codeburst on Medium, where people are continuing the conversation by highlighting and responding to this story.

Follow me on my coding journey on Instagram @ robynsilber