DEV Community: Ryan Thelin

TensorFlow.js tutorial: Get started with the ML library

Ryan Thelin — Fri, 30 Jul 2021 19:15:13 +0000

TensorFlow is one of the most popular tools for machine learning and deep learning. It's used by many big tech companies such as Twitter, Uber, and Google. TensorFlow.js is a JavaScript library used for training and deploying machine learning models in the browser. TensorFlow.js was designed to provide the same features and functionalities as traditional TensorFlow, but for the JavaScript ecosystem.

Today, we're going to dive deeper into TensorFlow and discuss its benefits, features, models, and more. We'll finish the article with a walkthrough of the Layers API, which is one of the two ways to create a machine learning model with TensorFlow.js. Let's get started!

We’ll cover:

What is TensorFlow?
What is TensorFlow.js?
Installing TensorFlow.js
Creating a ML model with the Layers API
Wrapping up and next steps

Get hands-on with machine learning

This learning path will help you master important ML skills and techniques.

Become a Machine Learning Engineer

What is TensorFlow?

TensorFlow is an open-source machine learning platform. It was created in 2015 by the deep learning artificial intelligence research team at Google. TensorFlow has an extensive environment that includes many different tools, libraries, and user resources.

TensorFlow uses machine learning and deep learning algorithms. It uses Python for an accessible front-end API for building apps within the framework and then executes those apps in C++. With TensorFlow, we can train and run deep neural networks for many different purposes, such as image classification, natural language processing, and more.

TensorFlow is known to have an intuitive and easy-to-learn set of APIs. Their goal is to make it easy for you to learn and implement machine learning, deep learning, and scientific computing. In 2019, they released TensorFlow 2.0, which enhanced the platform and made it easier to work with and more efficient. One of their big changes was using the Keras API for model training.

With TensorFlow, we can create dataflow graphs. Each node we see in the graph represents a mathematical operation, and each edge between the nodes is called a tensor. A tensor is a multi-dimensional array.

TensorFlow has many benefits, such as:

Portability: TensorFlow allows us to train and deploy our models easily, no matter what language or platform we use.
Powerful: With TensorFlow, we can create complex topologies using features like the Keras Functional API and the Model Subclassing API.
Debugging: We can use eager execution for quick and intuitive debugging.
Community: TensorFlow has a large and active community.
Abstraction: TensorFlow has multiple levels of abstraction so we can pick the right one for our needs.

What is TensorFlow.js?

TensorFlow.js (TFJS) is an open-source machine learning library that we can run anywhere that we run JavaScript. It supports WebGL, which is the browser interface to OpenGL. OpenGL is an API used for rendering 2D and 3D vector graphics. The goal of TensorFlow.js was to recreate the experience of traditional TensorFlow, but for the JavaScript ecosystem.

TFJS allows JavaScript code to be executed on a GPU. It allows us to build deep neural networks that we can easily integrate into new or existing web applications and is heavily based on the Keras API.

We can use TensorFlow.js in the following platforms:

Client-side in the web browser using JavaScript
Server-side and with IoT tools using Node.js
Desktop and web apps using Electron
Native mobile apps using React Native

TensorFlow.js models

TensorFlow.js provides pre-trained, out-of-the-box machine learning models that we can use in our projects. Some of these trained models and use cases include:

Image classification
Object detection
Body segmentation
Speech command recognition
Simple face detection
Transfer learning
And much more

With these models, JavaScript developers have built a lot of really cool demos, such as:

LipSync by YouTube: This demo uses the Facemesh model to score your lip-syncing accuracy.
Emoji Scavenger Hunt: In this demo, you use your phone's camera to find emojis in the real world.
Webcam Controller: In this demo, you play Pac-Man using images trained in your browser.

If you want to check out the code for any of these existing models, you can visit the tensorflow/tfjs-models GitHub repository to dive deeper! To check out the code for the demos, you can visit tensorflow/tfjs-examples on GitHub.

Keep the learning going.

Learn fundamental machine learning techniques without scrubbing through videos or documentation. Educative’s text-based learning paths are easy to skim and feature live coding environments, making learning quick and efficient.

Become a Machine Learning Engineer

Installing TensorFlow.js

The two most common ways to install TensorFlow.js in your browser include:

Installation with npm
Installation with script tags

If we want to install using npm, we can use npm cli or yarn.

npm cli installation:

npm install @tensorflow/tfjs

yarn installation:

yarn add @tensorflow/tfjs

If we want to install using script tags, we can add the following tag to our main HTML file:

<script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@2.0.0/dist/tf.min.js"></script>

Creating a ML model with the Layers API

In TensorFlow.js, there are two ways to create a machine learning model. We can either use the higher-level Layers API to build a model using layers, or we can use the Core API with lower-level operations. Today, we're going to take a closer look at the Layers API.

With the Layers API, we can either create a sequential model or a functional model. The sequential model is the most common type of model. We can create one by passing a list of layers to the sequential() function using const. Let's take a look:

const model = tf.sequential({

indent layers: [

double indent tf.layers.dense({inputShape: [692], units: 35, activation: 'relu'}),

double indent tf.layers.dense({units: 15, activation: 'softmax'}),

indent ]

});

Note: When providing the inputShape, leave out the batch size. As an example, let's say we plan to give our model tensors of shape [X, 692], where X is any batch size. We would specify our inputShape as [692] when making our model.

Wrapping up and next steps

Congrats on taking your first steps with TensorFlow.js! It's a great tool to add to your machine learning workflow. With TensorFlow, it's easy to train and deploy machine learning and [deep learning models in the browser. Machine learning is a vast field, and there's still so much more to learn. Some recommended concepts to cover next include:

Image processing with datasets
Building advanced data pipelines with TensorFlow
Analyzing and manipulating data in Pandas and Numpy

To get started learning these concepts and much more, check out Educative's learning path Become a Machine Learning Engineer. In this hands-on path, you'll learn the essential ML techniques to stand out from the competition. By the end, you'll have job-ready skills in data pipeline creation, model deployment, and interference. The path even has a chapter dedicated to deep learning with TensorFlow.

Happy learning!

Continue reading about machine learning

What is cloud native? What to know for your interview

Ryan Thelin — Thu, 29 Jul 2021 23:02:33 +0000

Cloud-native technologies have become an important part of modern software development. The cloud-native architecture allows us to handle sudden surges in demand in an organized and efficient way through the use of containers, microservices, DevOps, and APIs. With cloud jobs in such high demand, you can help set yourself apart from the competition by developing strong cloud skills.

In this article, we’ll explore the term cloud-native and discuss the benefits of cloud-native architecture, how to build a cloud-native application, and what to know for your cloud interviews.

Let’s get started!

We'll cover:

What is cloud native?
Cloud-native vs. traditional applications
How to build a cloud-native application
What to know for a cloud-native interview
Wrapping up and next steps

Get hands-on with cloud native app development

This interactive course will help you walk you through the journey to creating your first cloud-native web application.

Cloud Native Development with Tailwind, Google Cloud, and Firebase

What is cloud native?

Cloud-native is an approach to application development that uses the cloud computing delivery model. Cloud-native development was designed to enhance modern application development by employing the scalability, resiliency, and flexibility that the cloud provides.

As defined by the Cloud Native Computing Foundation (CNCF), “cloud-native technologies empower organizations to build and run scalable applications in modern, dynamic environments such as public, private, and hybrid clouds.”

Note: The CNCF was created by the Linux Foundation in 2015. It’s an open-source software foundation that promotes cloud-native technologies. Companies like Microsoft, Oracle, and Intel are members of the foundation. They support open-source projects such as Kubernetes, Envoy, and many more.

Cloud-native app development leverages things like containerization, service meshes, declarative APIs, and microservices to allow you to build, deploy, and manage high-impact cloud-native applications. Cloud-native services use technologies such as Docker, Kafka, Kubernetes, and serverless functions to help you efficiently build and run scalable applications in private and public cloud environments.

Cloud-native architecture

Cloud-native architecture focuses on designing apps or services that were made to exist in the cloud rather than on-premises infrastructure. The cloud-native architecture enables us to create and deploy applications that are easy to maintain and have flexibility without relying on physical servers.

Microservices and serverless functions are very important in cloud-native architectures. Microservices are one of the main parts of cloud-native app architecture. Many companies use them because they support DevOps, improve scalability, reduce costs, and enable flexibility.

Microservices and containerization support cloud-native apps by enabling us to switch between cloud providers, deploy services independently, and deploy services in different languages or frameworks without issues. There are many benefits to implementing a cloud-native architecture into your application development process. Let’s take a look at some of the benefits and challenges:

Benefits

Continuous integration: Microservices help us with continuous integration and continuous delivery efforts because the development lifecycle is reduced and more processes are automated.
Container orchestration: Container orchestrators can schedule and allocate resources based on user needs. Open-source container orchestration platforms help us identify bugs in specific containers so we can find the root of the problem instead of affecting the entire application.
Portability: Containerized microservices are very portable, which means we don’t need to rely too much on one specific cloud provider.
Reduced downtime: Container orchestrators help us deploy software updates with less downtime.
Fast development time: Cloud native architecture helps us speed up the app development process for organizations that have compute resources spread across different environments. This also allows us to get more value from the hybrid cloud.

Challenges

Lack of DevOps: If your organization doesn’t establish a DevOps pipeline, it may be difficult to manage the distributed workflows and microservices within your application.
Microservices: Certain microservices are dependent on specific types of operating systems, so make sure to consider that before moving forward.
Dependencies: If you transition from a traditional application to a cloud-native application, dependencies and interdependencies may arise.

Cloud-native vs traditional applications

Traditional apps are basic apps that run on a mainframe environment or that have a client/server environment. Cloud-native apps implement the cloud computing delivery model to improve the app development process.

Let’s take a look at some of the main differences between cloud-native apps and traditional apps:

Cloud native

Predictable: Cloud-native apps follow a framework that helps optimize resiliency through predictable actions. Cloud platforms use an automated, container-driven infrastructure that drives the way we write our software.
Collaborative: Since cloud-native architecture uses DevOps, the app development process is more streamlined.
Practical capacity: Cloud-native app development automates infrastructure provisioning, which helps allocate the appropriate resources at the time of deployment.
Independent: The microservices architecture breaks apps into smaller services. This makes it easier to perform updates and scale the services without affecting other aspects of the application.
Continuous delivery: Individual updates can be released as soon as they’re ready.
Operating system abstraction: The cloud-native architecture allows us to break away from underlying infrastructure dependencies and focus on the software.

Traditional

Not predictable: Traditional apps are developed in specific ways, and they don’t use the benefits of the cloud computing delivery model. This means that traditional apps may take longer to build, and they may have more infrequent releases.
Isolated: Traditional app development doesn’t use DevOps, so there’s typically less collaboration between different teams.
Large capacity: Custom infrastructure solutions may delay app deployment due to their oversized capacity.
Dependent: The monolithic architectures bundle services into single packages, which causes dependencies between services. This can affect updates and scaling.
Delayed delivery: Updates may be delayed, which affects the performance of the application.
Operating system dependency: Traditional app development typically involves dependencies between the application itself and its underlying operating system.

Keep the learning going.

Learn about cloud native app development without scrubbing through videos or documentation. Educative’s text-based courses are easy to skim and feature live coding environments, making learning quick and efficient.

Cloud Native Development with Tailwind, Google Cloud, and Firebase

How to build a cloud-native application

There are many different tools and practices we can use when building and operating cloud-native applications. Let’s take a look at some of the fundamentals:

DevOps

DevOps is a combination of philosophies, practices, and tools that increases an organization’s ability to deliver apps and services quickly and efficiently. DevOps allows us to fully use the native cloud capabilities and ensures that dev and operations teams work together with regular communication and common goals. With DevOps, our software development processes and more consistent and efficient.

Microservices

Microservices architecture involves developing applications as collections of smaller services. Each microservice can be manipulated independently of other services within the same application. This enables a more streamlined application development lifecycle without negatively impacting users.

Continuous delivery

Continuous delivery is made possible by Agile development practices. It means that we constantly make phased software changes through automation. It’s a very reliable way to release and deliver software more frequently and safely.

APIs

Since cloud-native applications rely heavily on microservices, we need a well-defined way for these separate services to communicate with each other. This is where APIs come in. Application programming interfaces (APIs) connect products and services and allow them to easily communicate so we can maximize the development process.

Containerization

Using containers gives us more efficiency and speed compared to traditional virtual machines. With containerization, a single operating system instance is divided across one or more containers, which allows us to create and deploy individual microservices.

What to know for a cloud-native interview

If you want to work in the cloud space, it’s important to know about cloud-native application development. Let’s discuss some fundamental information you should know and useful things you can do before your cloud-related interview:

Cloud computing

Your expected skills and knowledge will depend a lot on the position you’re interviewing for. Overall, you still need to have a solid understanding of the fundamentals of cloud computing. Make sure you have the knowledge to answer basic questions about the cloud.

Your preparation and study topics will depend on the position you’re applying for. Make sure to brush up on the relevant ideas and technologies that pertain to the job you want. It’s also important that you demonstrate that you have some hands-on experience with cloud computing. If you don’t have experience, you should have a solid understanding of the concepts and be able to explain them at a higher level.

Cloud certification

A cloud certification shows potential employers that you have a solid understanding of the fundamentals of cloud computing. Over 80% of hiring managers say that cloud certifications make applicants more desirable. The most popular certifications on the market now are for AWS, Azure, and GCP. Regardless of the certification you choose, multi-cloud skills are in high demand, so you’ll have room to move around.

DevOps

DevOps is a strategy to help speed up application development by allowing operation feedback to come right to the developers. This means that cloud engineers follow their app throughout its entire lifecycle. For interviews, prepare to answer questions about things like disaster control, feedback, and automated data management.

Soft skills

Don’t forget the soft skills! Now more than ever, tech companies are looking for well-rounded candidates with technical skills and soft skills. Make sure to highlight experiences that demonstrate your flexibility, adaptability, communication skills, and your customer service mentality.

Wrapping up and next steps

Congrats on taking your first step with cloud-native applications! Cloud-native development is growing in popularity, so it’s an important thing to know for a career in software development. There’s still so much more to learn about cloud-native app development, such as:

Setting up a continuous deployment pipeline
Feature toggles
Monorepo

Getting hands-on experience with cloud-native applications is a great way to demonstrate to potential employers that you have the relevant skills and experience with the cloud. To start learning about the listed concepts and a lot more, check out Educative’s course CloudNative Development with Tailwind, Google Cloud, and Firebase. In this curated course, you’ll get hands-on experience in developing, testing, and managing a complete cloud-native application.

By the end of the course, you’ll have the foundational knowledge you need to develop cloud-native applications on your own or with your team. You’ll also have great experience to talk about in your next interview!

Happy learning!

Continue reading about the cloud

Learn Python 3: Python basics in 7 coding challenges

Ryan Thelin — Tue, 06 Jul 2021 20:08:37 +0000

Python 3 is the latest version of Python, a popular programming language used mainly for web development, data science, and machine learning. Python has quickly become one of the most popular programming languages for new developers because of the wide range of uses in software development and some of the great improvements added since Python 2.

Today, we'll walk you through a hands-on, challenge-based tutorial to get you started with Python quickly!

Here’s what we’ll cover today:

Why challenge-based learning?
1. Hello World
2. String concatenation
3. List
4. Slicing
5. Branching
6. For loop
7. Functions
What to learn next

Learn Python 3 in half the time with hands-on practice

Our new 50 challenge Python course lets you skip the book work and get right to hands-on learning, with challenges ranging from beginner to expert difficulties.

An Intro to Python 3

Why challenge-based learning?

Not everyone learns new programming languages the same way. For many aspiring Python programmers, book learning is inefficient and doesn't lead to lasting learning. The main flaws of book learning are that it doesn't invite the reader to directly engage and it encourages memorization instead of the natural exploration of programming concepts.

To avoid the downsides of book learning, many would rather learn by exploring Python code through hands-on, challenge-based crash courses. This method is great for hands-on learners because it allows absolute beginners to learn both the theory and pragmatic use case for every basic concept or algorithm.

The challenges encourage you to explore the problems naturally and learn to use Python syntax through investigation rather than lecturing.

1. Hello World

Let’s start with a basic puzzle that uses the print() function.

print('hello world')

The print() function allows you to connect your program to the outside world. This function, as the name indicates, prints a value to the standard output.

You can think of the standard output as the environment in which your Python program lives. Your standard output is the air around you. Let’s say you shout “Ouch!” Every person in your environment can read from your standard output that you just experienced pain.
The data that is printed to the standard output is of the string data type.

A string is a sequence of characters.

You can define a string in Python in any of the following ways:

Single quotes ('hello world')
Double quotes ("hello world")
Triple quote ('''hello world''' and """hello world""")

In the puzzle, we use single quotes to define our string.

Challenge 1: Hello World

What is the output of the above code?

A) hello world
B) 'hello world'
C) Hello World

Solution

The correct answer is hello world because the quotes are used to denote the string but are not parts of the string.

2. Variables

Now we'll introduce the concepts of variables and float division.

x = 55 / 11
print(x)

The puzzle has two goals.
First, it introduces the concept of variables. Python evaluates the result of the expression on the right side of the equation and stores it in the variable x. After defining the variable, you can access it at any point in the program code.

Second, it forces you to read code carefully due to a twist:
Division operations always return a floating-point number. Thus, variable x stores the float value 5.0. The print function outputs the result as a float and not as an integer value 5.

This is the source of most errors in the code. People focus too much on what they mean (semantics) and too little on how they say it (syntax).

Tip: Programs always execute instructions according to syntax, which may be different from what you intended. The key is to get used to thinking like a computer.

Challenge 2: Variables

What is the output of the above code?

A) 5
B) 05
C) 5.0

Solution

The solution is 5.0.

Division always returns a floating-point number, meaning it always includes a decimal point value. Here, the decimal point value was zero but must still be included to be a floating point number.

3. List

This puzzle introduces lists, our first data structure in Python.

squares = [1, 4, 9, 16, 25]
print(squares[0])

The data type is “abstract” because you can use lists independently of the list elements’ concrete data types. Most complex algorithms that you'll learn later will use lists as a building block. Many famous algorithms such as quicksort are based only on a single list as their core data structure.

The pythonic way of handling lists and list access is simple and clean. You can create a list by writing comma-separated values between the opening and closing square brackets.

lst = [1, 4, 9, 16, 25]

You access the i-th element in a list lst with the intuitive bracket notation lst[i]. This notation is consistent for all compound data types, such as strings and arrays.

Challenge 3: Lists

What is the output of the above code?

A) 1
B) 4
C) 9
D) 16
E) 25

Solution

The correct answer is 1.

The index passed to a list indicates the position of the desired element. Indices are numbered starting with 0. Therefore, calling the 0th element of the list prints the first number, 1.

Keep building your Python programming experience.

Learn Python concepts from data structures to decorators, all with step-by-step challenges. Educative's hands-on courses let you learn the languages and tools you need quickly, with real-world examples and in-browser code environments.

An Intro to Python 3

4. Slicing

Now, we'll explore how to use slicing and some more advanced variable manipulation.

Slicing

Slicing is a Python-specific concept for accessing a range of values in sequence types, such as lists or strings. It is one of the most popular Python features. Understanding slicing is one of the key requirements for understanding most existing Python codebases.

The idea behind slicing is simple. Use the bracket notation to access a sequence of elements instead of only a single element. You do this via the colon notation of [start: end]. This notation defines the start index (included) and the end index (excluded).

Tip: A very common source of bugs is forgetting that the end index is always excluded in sequence operators.

For the sake of completeness, quickly look into the advanced slicing notation [start:end:step]. The only difference to the previous notation is that it allows you to specify the step size. For example, the command 'python'[:5:2] returns every second character up to the fourth character, i.e., the string pto.

len()

The len() function is a handy tool to get the length of built-in Python data types, such as strings, lists, dictionaries, or tuples.

Challenge 4: Slicing

What is the output of the above code?

A) galaxy
B) alaxy
C) 5
D) 6

Solution

The code outputs the number 5 because len() checks the length of galaxy starting after the first element. The selected portion, alaxy, has 5 letters. Therefore, the program prints 5.

5. Branching

Now we're moving into some harder challenges. In this challenge, we'll introduce branching and conditional statements.

def if_confusion(
      x, y):

  if x > y:
    if x - 5 > 0: 
      x=y
      return "A" if y == y + y else "B"

    elif x + y > 0:
      while x > y: x -= 1
      while y > x: y -= 1
      if x == y:
        return "E"

  else:
    if x - 2 > y - 4:
      x_old = x
      x=y*y
      y = 2 * x_old

      if (x - 4) ** 2 > (y - 7) ** 2:
        return "C"
      return "D"
    return "F"


print(if_confusion(3, 7))

Just like any other programming language, Python also has Conditional Statements also known as Branching Statements. To create branches, you can use the keywords if, else, or elif. These statements return Booleans, true if the condition is met and false if it is not.

Tip: The computer does not execute the code strictly from top to bottom, and you shouldn’t either.

Instead, start where the program execution starts, which is at the bottom with the function call if_confusion(3, 7).
Now you know that x=3 and y=7. Then, you proceed to do what the interpreter does.

As x>y is false, you can skip the whole upper part of the function. Similarly, you can skip the if branch for x-2>y-4.

Challenge 5: Branching

What is the output of the above code?

A
B
C
D
E
F

Solution

The key is to notice the indentation. The first if statement asks if x is greater than y. This is false for our entered input of (3,7) so we do not enter that if block. Instead, we enter the corresponding else statement on line 15. Both of the if statements are not true and so we return F at the bottom of the else block.

6. For loop

Now that we've seen a while loop, we'll learn about for loops.

words = ['cat', 'mouse']
for word in words:
    print(len(word))

Tip: Repeated code is redundant and hard to read, debug, and maintain. As programmers, we should avoid redundant code at all costs.

The Python for loop statement is a way out of redundant code. With a for loop, you write code once and put it into different contexts.

Among the ingredients that make a programming language powerful are control flow statements. The Python for loop is one such control flow statement. It repeats the execution of the code body for all sequence elements, iterating over all elements in the order of the sequence. It's similar to a forEach loop found in Java or JavaScript.

In the puzzle, the variable word takes first the value cat and second the value mouse. We then print out the length of each word.

Challenge 6: For Loops

What is the output of the above code?

A) cat mouse
B) 3 5
C) cat
D) 3

Solution
The answer is 3 5.

The for loop repeats the code body for every word in the words list. The code body prints the length of the current selected word. The length of the first word is 3 and the length of the second word is 5.

7. Functions

For our final challenge, we'll take a look at a fundamental programming concept: functions.

def func(
        x):
    return x + 1


f = func
print(f(2) + func(2))

A function encapsulates a sequence of program instructions. The ideal function solves a single high-level goal.

For example, you can encapsulate the task of searching the web for specific keywords into a named function. This allows you to call for a search later using just a single statement.

Functions allow you to write code once and reuse it later or in other programs. Reusing code is more efficient than writing the same code each time. Suppose you want to calculate the square root of 145. You could either calculate it for the specific value 145 or define a function that calculates the square root for any value x.

Defining a function

You can define a function with the keyword def, followed by a name and the function’s arguments. The Python interpreter maintains a symbol table that stores all function definitions, i.e., mappings from function names to function objects.

This allows the interpreter to relate each occurrence of the function name to the defined function object. A single function object can have zero, one, or even many names.

In the puzzle, we assign the function object to the name func and then reassign it to the new name f. We can then use both the names to refer to the same code.

Upon the function call, the Python interpreter will find the function in the symbol table and execute it. This can make your code more readable when calling the same function in different contexts.

Challenge 7: Functions

What is the output of the above code?

A) 6
B) 3
C) 3+3

Solution

The solution is 6.

We first set up the function func to return x+1. We then add f as another valid name for the function. This allows us to call either func or f and execute the same code block. As a result, the final function all translates to (2+1) + (2+1).

What to learn next

Now that you've completed these 7 challenges, you have programming experience with the major building blocks of most Python 3 programs. Transitioning to a new language can be tough, but know that you're making a great investment in your education. Python is the best general-purpose language in use today and there has never been a better time to start learning Python!

As you continue your journey to become a python programmer, look for Python projects on concepts like:

Object Oriented Programming (OOP) with Python class inheritance
Python Standard Library
Implementation with popular outside technologies like Django or Pandas
Advanced Python 3 syntax like Lambda and Continue statements

To help you get to that point, Educative has launched our new Python course An Intro to Python 3. This course features 50 challenges that provide hands-on experience with all the skills you'll need to jump into building Python projects. The course's challenge-based learning approach is perfect for developers looking to transition to Python because it draws on your existing coding intuition to learn in half the time.

Happy learning!

Continue reading about Python Projects

Celebrating Pride: How to write gender-neutral coding tutorials

Ryan Thelin — Wed, 09 Jun 2021 21:08:09 +0000

Pride Month is an annual celebration for the month of June that is dedicated to celebrating Lesbian, Gay, Bisexual, Transexual, and Queer people and culture. It is also a time to reaffirm support for the LGBTQ+ community's continued struggle for equal rights and treatment in society.

The first Pride celebration was in New York in 1970 to remember the 1969 Stonewall Uprising, a demonstration oppose to the hate-fueled police raids on the Stonewall Gay club. Many historians view this and the following Pride celebration as a tipping point in the United States Gay Liberation Movement.

Educative is committed to building a better, more inclusive future for LGBTQ+ people, both in the developer community and the world at large. One way we can all do this is to think critically about how we write coding tutorials and examples.

Today, we'll explore how you can make your educational content more approachable for Queer and Non-Male identifying readers and increase the performance of your content at the same time!

Here’s what we’ll cover today:

How gendered language hurts content
Simple changes to make tutorials more inclusive
Wrapping up

Never miss Educative content again

Learn more about our Newsletter

How gendered language hurts content

Many online coding tutorials default to male pronouns. The most common instances of this are when discussing functionalities or when providing a hypothetical example. While the writers likely do not intend to offend, this gendered language can make Non-Male readers feel unwelcome in the developer space.

For example, it's common to find articles that say something like:

"A developer can use an array to store integers. This will allow him to access these integers in the future."

Here, we can see that the writer began with a gender-neutral term, "developer", but has then included a male pronoun, "him". The writer has therefore implied, perhaps unintentionally, that developers are inherently male.

Similarly, many writers will default to writing hypothetical examples using male pronouns exclusively. This is especially common for examples that discuss management or administrative positions.

For example, a tutorial may include sections like:

"Imagine we have a Product Manager that wants to connect his app to a database. He knows the database uses a NoSQL schema."

Like the first example, this hypothetical example implies that Product Managers are inherently male because it is an unspoken assumption.

Most male readers may not notice this because it matches their experience; they are a male developer so the developer being referred to as male seems natural. However, this type of implication is very disheartening for Non-Male readers because it can make them feel like an outcast or an exception within the developer community.

While a single instance of gendered language will not hurt the reader's sense of belonging in the community, these individual instances culminate over time to steady wear down the Non-Male developer's comfort as a member of the community.

We should avoid this because it excludes groups of people from the community and profession based on their natural-born characteristics.

From a content writer's perspective, the success of your content relies on the reader's passion for the profession and comfort level within the community. Readers who do not feel welcome in the community or feel out of place as a developer are not going to read community-made coding tutorial content. These are valuable readers that have been lost but could be easily retained with just a few changes to how we write tutorials as a community.

Simple changes to make tutorials more inclusive

We can easily avoid these problems by paying attention to the implications of gendered language and replacing it with a gender-neutral alternative.

Writing in gendered language is a hard habit to break so don't worry if you have to write first then revise when just starting out. Just making these small changes bit-by-bit will make a big difference to Non-Male readers.

Functionality explanations

The functionality of a coding concept is the same regardless of the gender of the user.

Therefore, we don't have to specify gender when explaining the concept and can simply use impersonal, gender-neutral language like "the developer" or "a developer". We can also replace any pronouns with "they/their", which are gender-neutral and can be used as a single or plural pronoun.

We can revise our previous example to instead be:

"A developer can use an array to store integers. This will allow them to access these integers in the future.

When discussing multiple people, use their titles in place of pronouns to avoid confusion:

The developer designed the app to learn from the user's in-app behavior. The user can limit the type of data tracked by the app.

Here, it's better to use "The user" instead of "they" because it makes it clearer which of the two established people we're referring to.

Both examples leave the developer as a blank slate to explain the topic and allow readers of all kinds to interface with the topic.

Hypothetical examples

Hypothetical examples are more specific and human-focused than explanations of abstract concepts. It's therefore even more important to use gender-neutral language to avoid making implicit claims.

Let's look back at our original hypothetical example and make it better:

"Imagine we have a Product Manager that wants to connect their app to a database. They know the database uses a NoSQL schema."

We can replace all male pronouns with gender-neutral pronouns to avoid making assumptions about the gender of the product manager. Since there is no second person in this example, we have no risk of confusing the reader by using only pronouns.

The problem with "he/she"

Many tutorials will use "he/she" and "his/her" in place of pronouns to try to include all readers.

For example, it's common to see a sentence like:

"The developer can use Azure services to access cloud storage. He/she will instantly gain access to many gigabytes of space and can access his/her data anywhere with an internet connection."

While this comes from a good place, using these either/or pronouns unintentionally excludes Non-Binary readers.

Similar to "he", "he/she" implies that only people that identify within the traditional gender binary are welcome within the community. This format has a history of being used for transphobic and queer gatekeeping and can offend Non-Binary readers.

Instead, it's better to use "they", "them", or just titles. Doing so not only invites more demographics of readers to engage with your content but also reduces visual clutter by cutting the forward-slash from the sentence.

Wrapping up

While it can be difficult to break the habit of using gendered language, it makes a big difference to Non-Male members of your audience and keeps them engaged with your content. It can be tricky to get into the habit of writing with gender in mind but you don't have to make sweeping changes at once.

In the end, what's important is that you're doing your best to welcome all kinds of developers to the community and improve your community engagement skills one article at a time.

Continue reading about social justice in tech

Top 5 Distributed System Design Patterns

Ryan Thelin — Wed, 02 Jun 2021 22:23:04 +0000

Distributed applications are a staple of the modern software development industry. They're pivotal to cloud storage services and allow web applications of massive scale to stay reactive. As programmers build these systems, they need fundamental building blocks they can use as a starting point and to communicate in a shared vocabulary.

This is where distributed system design patterns become invaluable. While sometimes overused, design patterns are a key skill recruiters are looking for and are essential to stand out in advanced system design interviews.

Today, we'll explore 5 of the top distributed system design patterns to help you learn their advantages, disadvantages, and when to use them.

Here’s what we’ll cover today:

What is a distributed system design pattern?
1. Command and Query Responsibility Segregation
2. Two-Phase Commit
3. Saga
4. Replicated Load-Balanced Services
5. Sharded Services
What to learn next

Ace advanced system design questions with ease

Practice top distributed systems questions and design patterns to use in your next system design interview.

Grokking the Advanced System Design Interview

What is a distributed system design pattern?

Design patterns are tried and tested ways of building systems that each fit a particular use case. They're not implementations but rather are abstract ways of structuring a system. Most design patterns have been developed and updated over years by many different developers, meaning they're often very efficient starting points.

Design patterns are building blocks that allow programmers to pull from existing knowledge rather than starting from scratch with every system. They also create a set of standard models for system design that help other developers see how their projects can interface with a given system.

Creational design patterns provide a baseline when building new objects. Structural patterns define the overall structure of a solution. Behavioral patterns describe objects and how they communicate with each other.

Distributed system design patterns are design patterns used when developing distributed systems, which are essentially collections of computers and data centers that act as one computer for the end-user. These distributed design patterns outline a software architecture for how different nodes communicate with each other, which nodes handle each task, and the process flow for different tasks.

These patterns are widely used when designing the distributed system architecture of large-scale cloud computing and scalable microservice software systems.

Types of distributed design patterns

Most distributed design patterns fall into one of three categories based on the functionality they work with.

Object communication: Describes the messaging protocols and permissions for different components of the system to communicate.
Security: Handles confidentiality, integrity, and availability concerns to ensure the system is secure from unauthorized access.
Event-driven: Patterns that describe the production, detection, consumption, and response to system events.

1. Command and Query Responsibility Segregation (CQRS)

The CQRS pattern focuses on separating the read and write operations of a distributed system to increase scalability and security. This model uses commands to write data to persistent storage and queries to locate and fetch the data.

These are handled by a command center, which receives requests from users. The command center then fetches the data and makes any necessary modifications, saves the data, and notifies the read service. The read service then updates the read model to show the change to the user.

Advantages:

Reduces system complexity by delegating tasks
Enforces a clear separation between business logic and validation
Helps categorize processes by their job
Reduces the number of unexpected changes to shared data
Reduces the number of entities that have modifying access to data

Disadvantages:

Requires constant back-and-forth communication between command a read-models
Can cause increased latency when sending high throughput queries
No means to communicate between service processes

Use Case

CQRS is best for data-intensive applications like SQL or noSQL database management systems. It's also helpful for data-heavy microservice architectures. It's great for handling stateful applications because the writer/reader distinction helps with immutable states.

2. Two-Phase Commit (2PC)

2PC is similar to CQRS in its transactional approach and reliance on a central command, but partitions are processed by their type and what stage of completion they're on. The two phases are the Prepare phase, in which the central control tells the services to prepare the data, and the Commit phase, which signals the service to send the prepared data.

All services in a 2PC system are locked by default, meaning they cannot send data. While locked, services complete the Prepare stage so they're ready to send once unlocked. The coordinator unlocks services one-by-one and requests its data. If the service is not ready to submit its data, the coordinator moves onto another service. Once all prepared data has been sent, all services unlock to await new tasks from the coordinator.

2PC essentially ensures that only one service can operate at a time, which makes the process more resistant and consistent than CQRS.

Advantages

Consistent and resistant to errors due to lack of concurrent requests
Scalable, can handle big data pools as easily as it can handle data from a single machine
Allows for isolation and data sharing at the same time

Disadvantages

Not fault-tolerant, prone to bottlenecks and blocking due to its synchronous nature
Requires more resources than other design patterns

Use Case

2PC is best for distributed systems that deal with high-stakes transaction operations that favor accuracy over resource efficiency. It is resistant to error and easy to track mistakes when they occur, even at scale.

Keep learning about distributed systems.

Knowledge of distributed systems is a top priority for modern recruiters. Prepare for your next system design interview with hands-on practice and insider tips. Educative's text-based courses let you get the experience you need to land your next job on the first try.

Grokking the Advanced System Design Interview

3. Saga

Saga is an asynchronous pattern that does not use a central controller and instead communicates entirely between services. This overcomes some of the disadvantages of the previously covered synchronous patterns.

Saga uses Event Bus to allow services to communicate with each other in a microservice system. The bus sends and receives requests between services and each participating service creates a local transaction. The participating services then each emit an event for other services to receive. Other services all listen for events. The first service to receive the event will perform the required action. If that service fails to complete the action, it's sent to other services.

This structure is similar to the 2PC design in that services are cycled if one cannot complete a task. However, Saga removes the central control element to better manage the flow and reduce the number of back-and-forth communication required.

Advantages

Individual services can handle much longer transactions
Great for the distributed system due to decentralization
Reduces bottlenecks thanks to peer-to-peer communication between services

Disadvantages

Asynchronous autonomy makes it difficult to track which services are doing individual tasks
Difficult to debug due to complex orchestration
Less service isolation than previous patterns

Use Case

Saga's decentralized approach is great for scalable serverless functions that handle many parallel requests at once. AWS uses Saga-based designs in many functions like step and lambda functions.

4. Replicated Load-Balanced Services (RLBS)

The RLBS pattern is the simplest and most commonly used design pattern. At the most basic level, it consists of multiple identical services that all report to a central load balancer. Each service is capable of handling tasks and can replicate if they fail. The load balancer receives requests from the end-user and distributes them to the services either using a round-robin fashion or sometimes a more complex routing algorithm.

The duplicate services ensures the application maintains a high availability for user requests and can redistribute work if one instance of the service should fail.

RLBS is often used with Azure Kubernetes, which is an open-source container orchestration technology made by Microsoft that offers automatic service scaling based on workflow.

Advantages

Consistent performance from the view of the end-user
Can quickly recover from failed services
Highly scalable with more services
Excellent for concurrency

Disadvantages

Inconsistent performance based on load balancer algorithm
Resource intensive to manage services

Use Case

RLBS is great for front-facing systems that have inconsistent workloads throughout the day but must maintain low latency, such as entertainment web apps like Netflix or Amazon Prime.

5. Sharded Services

An alternative to replica-based designs is to create a selection of services that each only completes a certain kind of request. This is called "sharding" because you split the request flow into multiple unequal sections. For example, you may have one shard service that accepts all caching requests and another that only handles high-priority requests. The load balancer evaluates each request when it comes in and distributes it to the appropriate shard for completion.

Sharded services are normally used for building stateful services because the size of the state is often too large for a single stateless container. Sharding lets you scale the individual shard to meet the size of the state.

Sharded services also allow you to handle high-priority requests faster. Shards dedicated to high-priority requests are always available to handle such requests the moment they come in rather than being placed in the queue.

Advantages

Allows you to scale shards for common requests
Easy to prioritize requests
Simple to debug due to natural sorting

Disadvantages

Can be resource-intensive to maintain many shards
Leads to loss in performance if shards are used disproportionately

Use Case

Sharded services are best when your system receives a predictable imbalance in request types but some requests have priority.

What to learn next

Distributed system design patterns are an essential part of any successful back-end system. However, these are just a few of the patterns used by professional software engineers.

Some patterns for you to learn next are:

Sidecar Pattern
Write-ahead Log
Split-Brain Pattern
Hinted Handoff
Read Repair

To help you master these advanced system design patterns, Educative has created the course Grokking the Advanced System Design Interview. This course walks you through the top advanced SDI questions with in-depth explanations and hands-on practice. You'll learn about all the fundamental design patterns an advanced systems engineer needs. By the end, you'll have real-world experience with all the design patterns tested most by top industry recruiters.

Happy learning!

Continue learning about distributed systems

Bytesize: Quantum computing and the future of programming

Ryan Thelin — Wed, 02 Jun 2021 22:19:42 +0000

Bytesize is our 5-minute infusion of developer history, speculation, or otherwise fun knowledge that you can enjoy during a work or study break.

When you set off to become a developer, you probably dreamed of working on self-driving cars, artificial intelligence, world-changing apps, or any number of other amazing products. However, there’s a lot of learning and beginner developer work you need to do before you can get there. This can be draining and can make you lose sight of what got you excited to be a developer in the first place.

When knee-deep in a tough concept or a product function that’s fighting back, Bytesize is here every week to give you 5-minutes to shake it off and let your imagination fly once more.

Never miss Educative content again

Learn more about our Newsletter

What is Quantum Computing?

Quantum Computing is a novel type of computer structure using quantum qubits instead of the traditional binary bit found in modern transistors. Qubits are unique because they can be set to 0 and 1 as well as be suspended in a quantum superposition between 0 and 1. The qubit is necessarily at a halfway point, but rather it's unknown whether the particle is clear or set.

The superposition state allows qubits to have 3 possible settings rather than the traditional 0 or 1. This changes the foundational structure of programs from a series of "yes" or "no" to one that offers an "I don't know" option. Qubits, therefore, allow computers to solve certain problems at a staggeringly fast rate compared to traditional computers, especially when dealing with analyzing large data sets or completing complex mathematical operations.

While the quantum computer excels at certain tasks, it's not a strict upgrade over standard hardware. In fact, researchers have found that quantum computers are as fast or slower to complete many day-to-day tasks that we'd consider basic. Considering the high cost to build these machines and the energy required to keep a qubit in its superposition, it's unlikely we'll soon be walking around with Quantum iPhones or laptops for use on every task.

Instead, the relationship between current computers and quantum computers will likely be similar to the relationship between GPU and CPU; each excels at specific tasks, and modern machines make use of when their ideal use case arises.

The two current ideas to allow for everyday use of quantum computing are:

Quantum Processing Unit (QPU): Like a CPU, the QPU would be a modularized piece of hardware that you could install in a desktop or laptop computer. The operating system would then relegate high volume analytical tasks to the QPU, ensuring it's always used for its intended use. This idea is a stretch dream until scientists can discover a superconductor that's effective enough to sustain sufficient energy for the qubit to be in superposition whenever needed.
Quantum Cloud Systems: A centralized, off-site quantum computer that other computers can use via the cloud. The system would theoretically work like current cloud storage systems where a third-party owns the computer and users pay based on the amount they use the system. Quantum Cloud systems seem to be a more feasible solution for the technology's current state and could start seeing use as early as the next 5 years.

What fields will quantum computing affect most?

So quantum computing is on the horizon, but how will it affect programmers when it becomes a reality?

Cybersecurity

Cybersecurity will need to be heavily revamped to maintain effectiveness. Many modern encryption systems use RSA encryption, which relies on current computers being unable to find all the prime numbers in a 500+ digit number.

While it would take several years for current computer systems to crack encryptions like this, quantum computers could do it in less than an hour. That means the cybersecurity community will need to come up with a new encryption algorithm that is uncrackable by both current and quantum computers.

On the other hand, quantum computers allow for new cryptographic tools like quantum cryptography. This theoretical system stores an encryption key in a quantum particle that enters a quantum state and cannot be accessed for a period of 30-60 years when it returns to a normal state. Any attempt to view the key would change its state due to the wave function collapse property, which says that quantum particles in superposition must change state when observed.

In short, while cybersecurity experts will lose a familiar tool, they will gain a new powerful form of cryptography that is theoretically impenetrable.

Machine learning and AI

The other biggest change will be with big data analysis. Machine learning is being used in a myriad of fields from financial prediction to robotics to weather forecasting. Each of these fields uses machine learning algorithms to analyze data as it is made available and make predictions as close to real-time as possible.

However, current hardware bottlenecks these technologies. Current computers are relatively slow at analyzing large sets of mixed data. There is therefore a floor for how close to live updates these systems can get.

Quantum computing excels at handling high volumes of data with staggering efficiency, meaning it could open the door to near-instant data analysis.

Financial predictions could more quickly react to changes and can process more variables in the market. AI and robots could immediately identify, evaluate, and respond to new stimuli such as changes in the environment. Weather forecasts could evaluate hundreds of live feeds of meteorological data and synthesize readings like air pressure, humidity, wind strength, and more to create more accurate and reactive predictions.

Overall, quantum computing will affect anything that relies on big data analysis.

Continue reading about these fields

Educative Raises $12 Million in Series A Funding

Ryan Thelin — Thu, 20 May 2021 22:05:17 +0000

We founded Educative with the mission to make every developer more productive and successful. It was an inspirational rallying cry for the early few who helped us found the company. Along the way, we’ve been fortunate enough to work with millions of developers. We saw first-hand that developers need real hands-on training to succeed, and the market has responded with a resounding agreement.

That’s why we’re excited to announce the completion of our Series A funding round. Matrix Partners led the round of $12 million with additional funding from new and returning investors, including Trilogy Equity Partners, Lookout founder Kevin Mahaffey, Mercury founder Immad Akhund, Segment founder Ilya Volodarsky, and several other angel investors. For additional information, we hope you’ll read the news release that we published this morning.

The incredible support of the developers who rely on our courses to land new jobs and upskill themselves has humbled us. We are also thankful to our team and our investors for their continued support in expanding our mission.

We founded Educative on the idea of making every developer more productive. We’d like to spend a few moments sharing our plan to use this investment to help developers.

We’re more than tripling our course offerings this year and building offerings for teams and enterprises that want to expand the skills of their employees.
We recently launched our business-to-business offerings to target our enterprise customers and their needs. We have already seen traction and growth with paying customers of teams and organizations of all shapes and sizes, which validates our belief in the opportunity to grow in the enterprise space.
We will continue to build the world-class courses you love -- hands-on, in-browser exercises that help you learn and develop your skills in key and emerging technologies.

To facilitate this growth, we will be hiring more than 200 new employees in our Seattle headquarters and around the world.

Ultimately, our promise to you is that we’ll continue to invest in ways that we think help you be more productive and more successful. That was our mission on our first day, and this round of investment will help us accelerate in that commitment.

Thank you for your support, and as always…

Happy learning!

Fahim and Naeem,
Co-Founders @ Educative

JavaScript Tutorial: Build Tetris with modern JavaScript

Ryan Thelin — Fri, 14 May 2021 16:03:58 +0000

Learning a new programming language is difficult and not everyone learns the same way. For many, hands-on exploration on a project or interactive tutorial is the key to lasting learning.

Especially for intuitive languages like JavaScript, building projects helps to provide context for how and why to use fundamental concepts in different applications. It also helps build your resume because you can show recruiters a collection of awesome projects to demonstrate your drive and developer skills.

Today, we'll help you get started on a JavaScript game development project to build Tetris. By the end of the article, you'll have all the foundational pieces you need to continue building on your own.

Here’s what we’ll cover today:

What is Tetris?
Styling the game
Designing the board
Creating the canvas
Next steps for your game

Learn JavaScript your way, in half the time

Pick up modern JavaScript skills while building a fun and fully featured project for your portfolio.

Game Development with JavaScript: Creating Tetris

What is Tetris?

Tetris is a classic arcade game created in 1984 by Alexey Pajitnov. The game requires players to rotate and move falling Tetris pieces. Players clear lines by completing horizontal rows of blocks without empty cells. If the pieces reach the top, the game is over.

Tetris is a popular project that lets aspiring game developers practice their skills in a simple environment. For example, you'll get hands-on practice with essential game design concepts, such as gameplay loop design, and implementing common game mechanics like user controls, score tracking, and collision detection. Unlike more complicated games, the behavior and visuals for Tetris are very simple. This lets you practice applying JavaScript basics for game development rather than figuring out animation or complex player behavior flowcharts.

For this example, we'll start by using the simplest tools and build the complexity towards the end.

To make Tetris, you'll need to know:

HTML/CSS styling
JavaScript classes, variables, and scope
Arrow functions
Template literals
Spread vs Rest
Destructuring

Styling the game

First, let's set up the basic UI elements: the play area, a start button, and readouts to track score, lines, and level. We'll use Flexbox and CSS Grid to position the elements correctly.

<!-- index.html -->
<div class="grid">
  <canvas id="board" class="game-board"></canvas>
  <div class="right-column">
    <div>
      <h1>TETRIS</h1>
      <p>Score: <span id="score">0</span></p>
      <p>Lines: <span id="lines">0</span></p>
      <p>Level: <span id="level">0</span></p>
      <canvas id="next" class="next"></canvas>
    </div>
    <button onclick="play()" class="play-button">Play</button>
  </div>
</div>

// styles.css
.grid {
  display: grid;
  grid-template-columns: 320px 200px;
}

.right-column {
  display: flex;
  flex-direction: column;
  justify-content: space-between;
}

.game-board {
  border: solid 2px;
}

.play-button {
  background-color: #4caf50;
  font-size: 16px;
  padding: 15px 30px;
  cursor: pointer;
}

A fundamental part of 80s games was the highly recognizable bitmap font. Press start 2P is a free font from Google we can use to simulate the feeling.

To add the font, we need to link to it in the <head> section of our HTML document and set it to our desired font in the CSS style sheet.

 <!--index.html-->
<link
  href="https://fonts.googleapis.com/css?family=Press+Start+2P"
  rel="stylesheet"
/>

// styles.css
* {
  font-family: 'Press Start 2P', cursive;
}

Finally, code the infrastructure of the game board using JavaScript.
You'll need to add <script> elements at the end of our HTML document to import our JavaScript.

The bottom of your HTML document should look like this:

    <script type="text/javascript" src="constants.js"></script>
    <script type="text/javascript" src="board.js"></script>
    <script type="text/javascript" src="piece.js"></script>
    <script type="text/javascript" src="main.js"></script>
  </body>
</html>

constants.js will contain the code for our static play board. These values will never change regardless of player actions. The playboard will consist of 10 columns and 20 rows, with a block size of 30.

//constants.js
const COLS = 10;
const ROWS = 20;
const BLOCK_SIZE = 30;

Then, in the main.js file we'll include some code to manipulate the document object, which provides a programmable interface for the HTML document. This type of document is called a Document Object Model (DOM).

We can use the DOM to call the getElementByID to let us target specific elements and automatically scale our game to match the size of the user's browser window. This uses the canvas element new with HTML5, which allows us to create and use 2D shapes with ease.

The main.js file should look like this:

//main.js
const canvas = document.getElementById('board');
const ctx = canvas.getContext('2d');

// Calculate size of canvas from constants.
ctx.canvas.width = COLS * BLOCK_SIZE;
ctx.canvas.height = ROWS * BLOCK_SIZE;

// Scale blocks
ctx.scale(BLOCK_SIZE, BLOCK_SIZE);

By the end, you'll have the following files:

<!--index.html-->
<html>
<head>
  <link
href="https://fonts.googleapis.com/css?family=Press+Start+2P"
rel="stylesheet"
/>
</head>

<body>

  <div class="grid">
    <canvas id="board" class="game-board"></canvas>
    <div class="right-column">
      <div>
        <h1>TETRIS</h1>
        <p>Score: <span id="score">0</span></p>
        <p>Lines: <span id="lines">0</span></p>
        <p>Level: <span id="level">0</span></p>
        <canvas id="next" class="next"></canvas>
      </div>
      <button onclick="play()" class="play-button">Play</button>
    </div>
  </div>

</body>

//main.js
const canvas = document.getElementById('board');
const ctx = canvas.getContext('2d');

// Calculate size of canvas from constants.
ctx.canvas.width = COLS * BLOCK_SIZE;
ctx.canvas.height = ROWS * BLOCK_SIZE;

// Scale blocks
ctx.scale(BLOCK_SIZE, BLOCK_SIZE);

//constants.js
const COLS = 10;
const ROWS = 20;
const BLOCK_SIZE = 30;

//styles.css
* {
  font-family: 'Press Start 2P', cursive;
}

.grid {
  display: grid;
  grid-template-columns: 320px 200px;
}

.right-column {
  display: flex;
  flex-direction: column;
  justify-content: space-between;
}

.game-board {
  border: solid 2px;
}

.play-button {
  background-color: #4caf50;
  font-size: 16px;
  padding: 15px 30px;
  cursor: pointer;
}

Keep learning JS with hands-on projects.

Learn in-demand JavaScript skills without the bookwork. Educative's text-based courses are easy to skim and feature hands-on project environments to help you learn your way, in half the time.

Game Development with JavaScript: Creating Tetris

Designing the board

Now that we have created a container for our game, it’s time to start coding the logic. First, we need the board to be able to draw the falling pieces and keep track of the game state.

The board and pieces are both good candidates for a class. We can create a new instance of Board when starting a new game and a new instance of Piece every time a new piece enters the game.

For the Board class, we'll make a new board.js file. We want the board to reference the canvas every time the game starts so we'll include ctx in the Board constructor. We'll also include the this keyword to let us set and access properties within ctx.

//board.js
class Board { 
  constructor(ctx) {
    this.ctx = ctx;    
  } 
}

Tetris boards consist of many individual cells that are either empty or occupied. We'll represent empty cells with 0 and occupied cells with integers of 1-7 to represent colors.

To represent the rows and columns of the board, we'll use a 2D array (a matrix). We'll have arrays of integers to represent a row and an array of rows to represent the full board.

Since all games start with an empty board, we'll need a method that returns an empty board. We can use the built-in fill() array method to populate all elements of each row to 0. The constructor will call this method so all games start empty.

Our board.js file will now look like this:

//board.js
class Board { 
  constructor(ctx) {
    this.ctx = ctx;
    this.grid = this.getEmptyBoard();
  }

  getEmptyBoard() {
    return Array.from(
      {length: ROWS}, () => Array(COLS).fill(0)
    );
  }
}

Finally, we'll go back to main.js to add this new game functionality to the play button.

function play() {
  board = new Board(ctx);
  console.table(board.grid);
}

Now our game board is set up! You can use console.table() to see the matrix that controls the board.

Creating the canvas

Now we'll make sure our canvas element is ready to use. The canvas provides a blank canvas for our game to sit on.

We can also add a 2D drawing context over the canvas for drawing shapes, text, images, and other objects. It works similarly to programs like MS Paint in that you can choose your brush type and color then draw using code.

First, we want to make sure the canvas is the right size. It is 300x150 pixels by default but we want it to scale using the code we added above.

To do so, we add a canvas element to our index.html:

<canvas id="canvas"></canvas>

Then add a reference to the HTML <canvas> element element in the DOM (Document Object Model) using the getElementById method.

let canvas = document.getElementById('canvas');

Now we'll use the canvas context to render some pieces.

We can use the HTMLCanvasElement.getContext() method to get the canvas context where we render the graphics. This method needs an argument so we'll pass '2d' to get the 2D render context.

let ctx = canvas.getContext('2d');

Before we can draw we have to choose a color using the fillStyle() method.

ctx.fillStyle = 'red';

We can then use the fillRect() method from the context API to draw a simple rectangle filled with our chosen red color. fillRect() takes 4 arguments: the x and y coordinates where the shape should start and the width/height of the rectangle.

ctx.fillRect(x, y, width, height);

Since all Tetris pieces are collections of squares, we can use this single draw method for all of our pieces!

Animations

Now that we have the tools to draw our graphics, we have to be able to move them.

Canvas uses immediate rendering: Drawn shapes are immediately rendered on the screen, but are not stored as shape objects. Instead, canvas only recognizes the shape as filled pixels, meaning we cannot move the shape in one piece.

To show a moving shape, we have to delete the old shape using clearRect() and redraw it in a new position using fillRect(). Canvas animations are essentially like stop motion animation because they move a little bit in each frame.

Take a look at this example:

const {width, height} = this.ctx.canvas;
ctx.fillStyle = 'blue';
ctx.fillRect(0, 0, 10, 10);
ctx.clearRect(0, 0, width, height);
ctx.fillRect(1, 1, 10, 10);

Here, we select blue as our color then fill a rectangle at point 0,0. Then we clear the whole canvas using clearRect() and passing the width and height of the whole canvas. Finally, we draw a new rectangle of the same size and color at 1,1.

From the user's perspective, the rectangle moved down and to the right on the screen.

Now that you've got your canvas and drawing tools set up, you've got all the tools you need to start coding gameplay and a collection of game pieces!

Next steps for your game

This is a great start to your next portfolio project. Now that you've built the foundation of the game, your next step is to create objects that draw each unique Tetris game piece in its own color.

Each piece type will be represented by a 3x3 matrix where the piece is the filled cells and the surrounding empty space helps to rotate around the central cell.

[2, 0, 0],  
[2, 2, 2],  
[0, 0, 0];

The best way to do this is with a Piece class.

You'll also have to add keyboard support so the user can control the pieces. The best way to do this is to use keyboard event support built-in to modern browsers. You can set the program to listen for keyboard events like keydown, keyup, and so on at the document level using the addEventListener() method.

After these steps, you'll move onto adding more advanced features like:

Add collision detection and piece randomizer
Add line clearing if a row is filled
Track score, level, and past high scores
Increase responsiveness with asynchronous JavaScript

To help complete this project and learn JavaScript with hands-on experience, Educative has created the course Game Development with JavaScript: Creating Tetris. This course helps you pick up foundational skills in JavaScript and game development at the same time by building a fun browser game. By the end of the course, you'll have a fully-featured Tetris web game and will have gained experience with JavaScript skills from beginner to advanced.

Happy learning!

Continue reading about JavaScript

Bytesize: 3 Future Uses of Blockchain

Ryan Thelin — Mon, 10 May 2021 22:35:40 +0000

Bytesize is our 5-minute infusion of developer history, speculation, or otherwise fun knowledge that you can enjoy during a work or study break.

When you set off to become a developer, you probably dreamed of working on self-driving cars, artificial intelligence, world-changing apps, or any number of other amazing products. However, there's a lot of learning and beginner developer work you need to do before you can get there. This can be draining and can make you lose sight of what got you excited to be a developer in the first place.

When knee-deep in a tough concept or a product function that's fighting back, Bytesize is here every week to give you 5-minutes to shake it off and let your imagination fly once more.

Never miss Educative content again

Learn more about our Newsletter

International Commerce:

The most common use of Blockchain right now is cryptocurrencies like Bitcoin or Etherum. While most people know crypto's use in investing, it could also revolutionize international banking.

Currency conversions now take a long time and come with huge fees, sometimes around 20% of the transfer. That's because currency conversion isn't direct. Your bank must contact a bank in the target country and work to set up a transaction. Both of these banks need to pay their workers for the time, the third party used to authenticate their connection, and charge extra to make the transaction worthwhile for the company. This sluggish and lengthy process inhibits international trade and your options as a consumer.

Blockchain has economists excited because cryptocurrencies offer an intermediate and decentralized currency.

For example, say I want to convert from American Dollar to Japanese Yen. On my end, I can just press a button. Behind the scenes, my Dollar is used to buy a portion of a Bitcoin equal to the value then immediately resold for Yen.

Without the need for one or more middle parties, we can avoid high fees and the time it takes to connect to the decentralized server. The decentralized and secure ledger of cryptocurrencies could even allow companies to make large deals without the need for an authenticating bank. This concept has international business experts excited, with 90% of the European Payments Council they expect it to fundamentally change banking by 2025.

Online Voting

Democratic voting has been around for a long time, since the days of the Ancient Greeks. Unfortunately, the voting process hasn't seen much change since then. Much like the voting stones in Athens, most democratic nations still ask citizens to vote in person by placing their ballot in the box of their candidate. Ballot as a word reflects this stagnation as it developed from the Italian balla, meaning a colored ball used as a voting token in the 1500s.

The main problem of this system is that it assumes all voters can reach a ballot box and leads to long lines at voting locations. This centralized system makes it harder to vote, especially for those who can't take time off work to vote or cannot afford transportation.

Right now the best alternative to in-person voting is vote-by-mail systems with various layers of authentication. These systems are very secure and do not cause voter fraud. The problem they have is that the authentication process is costly and sometimes invalidates valid votes that have slight errors in formatting or signature matching. While it's the best solution we have right now, it still creates a barrier between the voter and the voting system.

That's why some experts are excited about Blockchain to enable online voting. The idea is to distribute a unique voting "coin" to all registered voters. Then, each voter adds their coin to an immutable blockchain associated with their preferred candidate.

Blockchain's encrypted, decentralized nature makes these votes hard to hack and manipulate, which is the main obstacle against online voting. Since there is no central administrator that can access the full ledger, the identity of the voter is secure. Further, the unique coins allow the system to easily track every interaction and verify each coin as it's entered into the system.

Blockchain does not require physical pickup by election officials and does not need to be authenticated by hand, which has been projected to lower the cost-per-vote to just $0.50.

In short, the system can verify votes but no central power can link them back to voters.

While still too early to implement at scale, Blockchain technology appears to be our current best option to enable online voting and further increase the availability of electoral engagement.

Swarm Robotics

Swarm Robotics is a form of AI that allows a group of robots to make decisions without a centralized director. Essentially, the swarm of robots uses a distributed peer-to-peer hive mind that allows the group itself to act as a decision-making device. This allows the group to make decisions, chart paths, and correct for obstacles faster than if it had to relay with an outside server. While long discussed in computer science academia, it's now being considered for application in drone-based delivery services.

Blockchain is showing initial promise as a key to bringing this theory to life. It's naturally suited to peer-to-peer relationships and has proved the most reactive option to unexpected stimuli in recent MIT tests of the ARGoS Etherium-based system. Blockchain also includes built-in cryptographic security systems, which address the fear of hacking the hive-mind.

This application of Blockchain is only just beginning to show promise, but its success will have staggering effects on our commercial transportation.

The technology is currently under open-source development. You can contribute on Github under the name "ARGoS-Blockchain interface"!

Continue reading about these technologies

Advanced YAML Syntax Cheatsheet

Ryan Thelin — Thu, 06 May 2021 22:21:58 +0000

YAML (YAML Ain’t Markup Language) is a data serialization language used to create key-value pair configuration files and app APIs. It's a superset of JSON and is formatted using line breaks and whitespace to improve readability.

While not a daily use technology, it's an important foundation for many modern technologies like Ansible and is, therefore, a prerequisite for higher-paying developer roles.

Today, we'll help you perfect your YAML knowledge so you can impress your next interviewer.

Here’s what we’ll cover today:

Validator and Parser
Anchors and Alias
Schemas
Escape Sequences
Separators and Directives
Wrapping up

Become a certified YAML professional

Stand out from other applicants with a YAML certification that you can earn in less than an hour.

Introduction to YAML

YAML Validator and Parser

While YAML is more readable than XML, it's easy to miss mistakes in formattings like the number of spaces across a multi-line section or forgetting newline markers. These can cause sweeping errors for the YAML parser, which interprets YAML into more machine-readable actions.

Parsing errors are hard to find by hand, so many developers choose to use a web validator or linter. These tools review your YAML document and highlight any potential errors to ensure you have valid YAML before putting it into use.

The most popular validator is YAMLLint, a free open-source tool available in your browser or on Github. YAMLLint is considered the most convenient linter because it provides error highlighting, autoformatting for copy/pasted YAML, and auto-correct options.

YAML Anchors and Alias

Anchors and Aliases are YAML constructions that allow you to reduce repeat syntax and extend existing data nodes. You can place Anchors (&) on an entity to mark a multi-line section. You can then use an Alias (*) call that anchor later in the document to reference that section. Anchors and Aliases are very helpful for larger projects as they cut visual clutter caused by extra lines.

The Alias essentially acts as a "see above'' command, which makes the program pause standard traversal, return to the anchor point, then resume standard traversal after the Anchored portion is finished. If you're familiar with Object-Oriented Programming designs, you'll feel right at home with Anchors.

Below, the build-test Anchor begins on line 3 and is called by Aliases on lines 13 and 15.

definitions: 
  steps:
    - step: &build-test
        name: Build and test
        script:
          - mvn package
        artifacts:
          - target/**

pipelines:
  branches:
    develop:
      - step: *build-test
    master:
      - step: *build-test

Overrides and Extensions

You can also tweak the Anchor when called by entering <<: before the Alias. Below this, you can write any desired changes. Mappings are overridden if the new mapping has the same name or is added afterward if different.

definitions: 
  steps:
    - step: &build-test
        name: Build and test
        script:
          - mvn package
        artifacts:
          - target/**


pipelines:
  branches:
    develop:
      - step: *build-test
    master:
      - step: 
          <<: *build-test
          name: Testing on Master #override
          ongoing: false #extension

YAML Schemas

Schemas are rulesets in YAML 1.2 that tell the loader/parser what each part of your YAML file converts to in actual commands. They're essentially a collection of if/then statements to process human-readable YAML tags into. For example, the YAML Core schema states that both !!str my string and my string are equivalent and should be parsed to the same action.

There is a default schema for general-purpose YAML, and many special-use schemas that are each suited for certain niche scenarios. You can even create your own custom schemas or download other user's schemas on the JSON Schema Store.

Custom schemas are helpful when configuration files include custom objects or if you want to create language-specific object serialization
s.

---
# Ruby Psych
dice: !ruby/Object:Dice [3, 6]

---
# perl YAML::XS, YAML.pm, YAML::Syck (Dump and Load)
dice: !!perl/array:Dice [3, 6]

---
# perl YAML.pm, YAML::Syck (Load)
dice: !perl/array:Dice [3, 6]

---
# Pyyaml
dice: !!python/object/new:__main__.Dice
  - !!python/tuple [3, 6]

There are three default schemas for YAML are:

Failsafe Schema: A minimalist schema that only supports String (!!str), Map (!!map), and Sequence (!!seq) tags. Failsafe is guaranteed to work with any YAML document due to its simplicity, but it does not support any complex tags.
JSON schema: A foundational schema designed to reliably parse equivalent YAML and JSON files to the same end result. This is the most commonly used schema and is the starting point for most schemas. It supports all failsafe tags, as well as Boolean (!!bool), null (!!null), Integer (!!int), and Float (!!float).
Core Schema: The default YAML schema that widens the matching criteria on the YAML side. It is essentially a less opinionated version of the JSON schema. For example, JSON accepts Booleans that achieve the criteria "Match: true | false". By comparison, here is Core's Boolean criteria: "true | True | TRUE | false | False | FALSE".

Keep the learning going.

Brush up on your expert YAML skills and earn a certificate at the same time. Educative's text-based courses are easy to skim and feature live coding environments, meaning you can better your skills in half the time.

Introduction to YAML

YAML Escape Sequences

YAML's readable syntax is only possible because it uses indents and whitespace over inline syntactic markers like square brackets or curly braces. However, this can get difficult when using special characters with quotation mark scalars.

YAML offers Escape Sequences to allow you to indicate if the character should be interpreted as a special character or as part of the scalar. For example, you could escape a single space using   to create a string with a value of .

Escape Sequences come in 3 types:

Entity Escapes, which allow you to use otherwise syntactically important characters by space ( ), colon (:), ampersand (&).
Unicode Escapes, which let you add a space (\u0020), single quote (\u0027), or double quote (\u0022) by calling their unique key directly from the Unicode key-value pairs list.
Quoted Escapes, which let you display quoted sentences using additional quotes. For example, double quotes can be shown within single quotes (‘ "quote" ’) or nested within another set of double quotes ("abc "quote" cba") and with nested single quotes (‘ ‘quote’ ’).

Note: A full list of YAML Escape Sequences can be found in the official YAML Specification.

YAML Separators and Directives

You may have noticed that all YAML documents begin with ---. This notifies the parser that this data is a separate chunk but was sent as part of the same request for efficiency.

Another more advanced separator is ..., which marks the end of a document. The end-of-document separator must be followed either by a beginning-of-document separator (---) or a set of directives. Directives are defined settings marked by % that comes before a document and are followed by ---.

This means ... and --- are needed to mark the boundaries of the directive space. The two current directives are %YAML, which lets you set the YAML version for the coming document, and %TAGS, which lets you create custom shorthands for tags you'll use in the document.

Directives are only useful in niche circumstances, like using an old YAML document that's too large to update. Usually, you will not need directives or a document separator.

doc 1 
... 

%TAG !foo! !foo-types/ 

--- 

doc 2

YAML Timestamp

Timestamp is a helpful data type that lets you store times as a unit rather than as a collection of different numbers. It's marked by the !!timestamp data tag and can hold various levels of specificity such as simple yyyy/mm/dd or down to a fraction of a second 2001-12-15T2:59:43.10.
You can also separate date and time using spaces to make the timestamp more readable, like 2001-12-15 2:59:43.10

All timestamps are recorded as Coordinated Universal Time (UTC) unless another timezone is specified at the end of the timestamps. You define the timezone by including how many hours it is ahead or behind UTC.

For example, I could set a timestamp as Pacific Standard Time (PST) with a -8 at the end.

2001-12-15 2:59:43.10 -8`.

This is similar to DateTime used in popular programming languages like JavaScript or Python, except with how it handles timezone. DateTime records the time listed in the timezone of the host server by default.

This can lead to problems if working with networks from outside their native timezone. The computer needs to convert to UTC then to the destination timezone every time the date is called, slowing down processes.

Wrapping up

Good job tackling this advanced YAML syntax. While YAML might seem like a niche skill, it's a prerequisite for many jobs across the market. However, most coding interviews will not include YAML. The best way to demonstrate your YAML knowledge is to use it in a portfolio project or be able to show past experience with the technology.

To help you wow recruiters with your YAML skills, Educative has created Introduction to YAML. This course covers beginner to expert level syntax and techniques in a condensed, hands-on format. By the end of the course, you'll be able to use YAML with confidence and will have your own YAML certification to put on your resume.

Happy learning!

Continue reading about YAML and foundational skills

Spring Framework Tutorial: Getting Started with Spring

Ryan Thelin — Wed, 05 May 2021 23:00:51 +0000

While often overlooked as old-fashioned, the Spring Framework is still a popular application development tool desired by enterprise companies across the globe. Spring offers unparalleled control, top-notch security, and a time-saving dependency system using Spring Beans.

However, Spring is also notoriously difficult to learn due to its number of options and complex toolset.

Today, we'll help you start your Spring development journey with a beginner tutorial on how and why to use Spring. In the end, we'll even get you started on your first Spring portfolio project.

Here’s what we’ll cover today:

What is the Spring Framework?
Salient features of Spring
Spring Architecture and Components
Get started with Spring
Advanced Spring concepts to learn next

Learn Spring in half the time

Learn professional-level Spring techniques quickly with hands-on lessons.

The Complete Guide to Spring 5 and Spring Boot 2

What is the Spring Framework?

Spring is a lightweight, open-source application development framework that uses Java Enterprise Edition (Java EE) and Enterprise JavaBeans model (EJB).

Spring is often thought of as a "framework of frameworks" because it supports other integrated frameworks in the Java ecosystem like Struts, Hibernate, and Tapestry. Spring comes in many variants that are tailored to particular uses such as Spring MVC, Spring Boot, or Spring Security.

Spring is known for its dependency injection and Inversion of Control (IoC) systems, which allow you to create large-scale, loosely-coupled applications with ease. Spring is especially suited for financial and enterprise applications due to its speed, security, and easy-to-build transaction systems. The top employers of Spring developers are Citibank, eBay, Visa, and J.P. Morgan.

Overall, Spring Framework allows you to create enterprise-scale applications that are secure and can automatically handle low-level functionalities like maintaining container lifecycles and managing dependencies.

Advantages of Spring

Plain Old Java Object (POJO): Spring applications just use normal Java objects rather than servers or enterprise containers. This makes applications more lightweight.
Modularity IoC and MVC allows you to reuse components across your application without manually managing the dependencies of each
Strong support for Java ecosystem: Spring makes innovative uses of pre-existing technologies, such as ORM frameworks, JEE, and JDK timers
Scalable transactions: Spring offers a consistent, scalable transaction management interface for both local transactions and global transactions. This includes caching protocols.
Secure: Easy to implement security modules with authentication and validation features.
Flexible Configs: Can opt to use Java-based annotations or XML configuration

Disadvantages of Spring

Complexity: Spring Framework opts for increased control and complexity over ease of use. Spring is therefore harder to pick up than other web frameworks. While very powerful, Spring is best suited for experienced developers that can handle its steep learning curve.
Parallel Mechanisms: Spring's wide range of options means a single task can be accomplished in several ways. You'll need intricate knowledge of your available tools to choose the ideal solution and avoid cross-team confusion.
Lacking robust documentation: Spring's documentation is missing clear guidelines on a number of topics, especially around cybersecurity techniques. It's up to users to deal with common attacks like cross-site forgery and scripting attacks. > Many of these disadvantages were addressed by the invention of the Spring Boot module, which is highly opinionated and designed for microservice architectures. > > Most modern Spring applications are built on Boot but there are many older applications still maintained by long-standing companies.

Features of Spring

Inversion of Control (IoC): Shifts responsibility for dependencies from objects to the framework itself. Without IoC, each object must handle its own instance of the dependency. With IoC, the object simply lists that it needs a certain dependency and the framework configures and manages it automatically. This simplifies the app development process by consolidating the dependency system and reducing the workload on individual classes.
Aspect-Oriented Programming: Spring AOP allows you to have different class loaders to increase modularity and separate cross-cutting concerns.
Dependency Injection: The process Spring uses to automatically manage the dependencies of beans. Spring checks which beans are required for a particular bean to function and injects them as a dependency. Spring can perform dependency injection by using a constructor or by using a setter method.
Container Lifecycle Management: Automatically creates, manages, and configures application objects.
MVC support: Supports the MVC web architecture that separates functionalities between model, view, and controller layers.
Error Handling: Includes JDBC exception handling with an exception hierarchy system.

Spring Architecture and Components

Let's break down the fundamental pieces of a Spring Framework application to help you see the big picture.

Beans

Spring Beans are instances of classes that are managed by Spring. They are the most fundamental component of a Spring program.

Traditionally, objects would create personal instances of their dependencies. Spring manages all the dependencies of an object and instantiates the object into a bean after injecting the required dependencies. The @Component annotation is the most common method of defining beans.

@Component
public class Vehicle {
}

Beans have a set lifecycle and visibility based on their scope. There are six types of scopes: singleton, prototype, request, session, application, and websocket. The singleton and prototype scopes can be used in any application while the last four scopes are only available for a web application.

The default scope of a bean is singleton, in which only one instance of the bean is created and cached in memory. Multiple requests for the bean return a shared reference to the same bean. In contrast, prototype scope results in the creation of new beans whenever a request for the bean is made to the application context.

Autowiring

Spring's method of injecting beans into one and another. Spring identifies a selected bean's dependency, looks for a match, and then populates the dependency. The @Autowired annotation tells Spring to find and inject a collaborating bean into another. If more than one bean of the same type is available, Spring throws an error.

In the following scenario, two beans of type Operator are detected by Spring:

@Component
class Arithmetic(){
    @Autowired
    private Operator operator;
    //...
}

@Component
class Addition implements Operator {

}

@Component
class Subtraction implements Operator {

}

IoC Container

An IoC container is a framework that provides the Inversion of Control functionality. The IoC container manages the beans and creates any instances required.

For example, say we have the class Vehicle that depends on another class, Engine.

class Vehicle{

    private Engine engine;
    //...
}

With IoC, the programmer only needs to mention the dependency and Spring will do the rest. The IoC container will create instances of both classes and inject Engine into Vehicle as a dependency.

Spring Modules and Spring Projects

Modules are collections of tools grouped by their intended function. Developers can specify which modules beyond the basic set they'd like to import as dependencies for any given application.

Modules are organized in groups called Projects. Each Project contains modules that are specialized for working in a specific platform or application type. The project and module systems help to keep your program lightweight as you can choose to load only the tools used in the application.

The modules of the basic Spring Project architecture are shown below grouped together by their layer:

The Spring Core Container includes the 4 modules essential to use Spring: Beans, Core, Context, and Spring Expression Language (SpEL). These modules are responsible for the fundamental functionality of the Spring framework, like Inversion of Control (IoC), dependency injection, internationalization as well as support for querying the object at run time.

The Spring Data access/integration layer provides support for interacting with databases and managing data. It has 4 main pieces:

The Java Database Connectivity (JDBC) module, which allows the data layer to get, store, or interface with other systems without needing to write cumbersome standalone JDBC code.
The Object Relational Mapping (ORM) module, which allows your Spring web application to interface with ORM frameworks.
The Java Messaging Service (JMS) module, which allows Spring to produce messages of its own and consume messages from other systems. This is essential for reactive apps.
The Object-XML Mapping (OXM) module, which provides useful features to make object-to-XML file transformation easy.

The Web layer contains the Web, Servlets, Portlets, and Sockets modules used to create web applications.

The Test module addresses the cross-cutting concern of unit testing. The Spring Test framework supports testing with JUnit, TestNG, as well as creating mock objects for testing the code in isolation.

The AOP module provides Aspect-Oriented Programming functionalities like method interception, pointcuts, security, and logging features. Spring has its own module called Spring AOP that offers basic, aspect-oriented programming functionality. Advanced AOP functionality can be implemented through integration with AspectJ. AOP features cross-cutting concerns from business logic.

Outside of this basic project, Spring includes projects for all major use cases. These projects include modules that are too niche for a basic project but include invaluable APIs and functionalities for the target use.

For example, Spring Cloud allows the development of cloud native applications that can be dynamically configured and deployed. It provides functionality for handling common patterns in distributed systems. Other projects include Spring Boot, Spring Security, Spring DAO, Spring Context, and many more.

Keep learning the Spring Framework.

Learn Spring quickly by building live projects that show you how and why to use your new skills. Educative's text-based courses are easy to skim and feature live coding environments to help you get lasting learning at your pace.

The Complete Guide to Spring 5 and Spring Boot 2

Get started with Spring

Now we'll get you some hands-on experience with your first Spring application: a simple movie recommendation system.
Setting up a new project with Spring Framework is difficult because you need to set up the full architecture by hand, including which Apache Maven dependencies to use, whether to use XML or Java, and you must install a web server like Tomcat.

Instead, we'll use the Spring Boot project to automate much of the setup process and use its built-in web server.

How to start your project

We'll use Spring Initializr to create a Spring Boot project fast using its simple selection menu.

First, go to start.spring.io. You'll find a menu interface like the one below with settings selections and metadata fields.

For this project, we'll select "Maven Project", choose Java as our language, and choose the latest version of Spring Boot. Avoid "SNAPSHOT" versions for now because these are versions being alpha or beta-tested. Under "Project Metadata", enter io.datajek.springbasics for "GroupID" and movie-recommmender-system for "ArtifactID. The group ID and artifact ID are basically the package name and class name. You'd normally add module dependencies under "Dependencies", but this project only requires default Spring tools.

Once you've entered everything, press "Generate" to create a zip file with setup architecture. Unzip the folder into the desired location on your hard drive. This folder will contain a pom.xml file to import into Eclipse IDE.

After a short moment, you'll see the following hierarchy:

src/main/java where the Java code will be written
src/main/resources where the application properties are written
src/test/java where the tests will be written You can now right-click the MovieRecommenderSystemApplication.java and run it as a Java application to produce the following console output.

 .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.3.4.RELEASE)
2021-05-03 22:46:15.549  INFO 78 --- [           main] .b.m.d.MovieRecommenderSystemApplication : Starting MovieRecommenderSystemApplication v0.0.1-SNAPSHOT on b041f076fcbd with PID 78 (/Code/movie-recommender-system/target/movie-recommender-system-0.0.1-SNAPSHOT.jar started by root in /Code/movie-recommender-system/target)
2021-05-03 22:46:15.563  INFO 78 --- [           main] .b.m.d.MovieRecommenderSystemApplication : No active profile set, falling back to default profiles: default
2021-05-03 22:46:16.458  INFO 78 --- [           main] .b.m.d.MovieRecommenderSystemApplication : Started MovieRecommenderSystemApplication in 1.41 seconds (JVM running for 1.855)

Congratulations, you set up your first Spring application with Spring Boot!

Adding a Dependencies

Now, we'll add a simple implementation of the movie recommender using Spring's dependency system. The program will take a movie title as input and return three movie titles of the same genre. For now, we'll be hardcoding our output so you can focus on learning the program's structure.

First, create a new class in src/main/java named RecommenderImplementation.

Next, we'll add the recommendMovies method to RecommenderImplementation. The recommendMovies method will take a String movie title as input and return the three recommendations in a String array.

Use the hardcoded implementation below:

public String[] recommendMovies (String movie) {
    //use content based filter to find similar movies
    //return the results
    return new String[] {"M1", "M2", "M3"};
}

Now, create an instance of the RecommenderImplementation class in the MovieRecommenderSystemApplication file, then call the recommendMovies method through the RecommenderImplementation class.

public static void main(String[] args) {
    RecommenderImplementation recommender = new 
RecommenderImplementation();    
    String[] result = recommender.recommendMovies("Finding Dory");
    System.out.println(result);
}

Next, we'll implement content-based filtering to find recommendations. To keep recommendMovies independent of the filtering logic, we'll create a new class called ContentBasedFilter with a method called getRecommendations. This method would be where you could implement complex filtering that looks at relevant data like watch history, user-match rating, and so on. Keep these ideas in mind for when you continue expanding this project after the tutorial.

For now, we'll hardcode getRecommendations to return the same three movies.

public String[] getRecommendations(String movie) {
    //logic of content based filter
    return new String[] {"Happy Feet", "Ice Age", "Shark Tale"};
}

We can now use the methods of the ContentBasedFilter class in the RecommenderImplementation class. Replace the previous hardcoded implementation of recommendMovies with the following dependency-based implementation.

public String[] recommendMovies(String movie) {
    ContentBasedFilter filter = new ContentBasedFilter();
    String[] results = filter.getRecommendations("Finding Dory");
    return results;
}

Finally, we'll add a toString method to the main method to make the String array readable as an output.
Your program will now look like this:

package io.datajek.spring.basics.movierecommendersystem.lesson1;
import java.util.Arrays;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MovieRecommenderSystemApplication {
    public static void main(String[] args) {

        //SpringApplication.run(MovieRecommenderSystemApplication.class, args);
        //create object of RecommenderImplementation class
        RecommenderImplementation recommender = new RecommenderImplementation();    

        //call method to get recommendations
        String[] result = recommender.recommendMovies("Finding Dory");

        //display results
        System.out.println(Arrays.toString(result));
    }
}

package io.datajek.spring.basics.movierecommendersystem.lesson1;
public class RecommenderImplementation {
    public String [] recommendMovies (String movie) {

        //use content-based filter to find similar movies

        ContentBasedFilter filter = new ContentBasedFilter();
        String[] results = filter.getRecommendations("Finding Dory");

        //return the results
        //return new String[] {"M1", "M2", "M3"};
        return results;
    }
}

package io.datajek.spring.basics.movierecommendersystem.lesson1;
public class ContentBasedFilter {
    public String[] getRecommendations(String movie) {

        //implement logic of content-based filter

        //return movie recommendations
        return new String[] {"Happy Feet", "Ice Age", "Shark Tale"};
    }
}

The current implementation is tightly coupled because the RecommenderImplementation class depends on ContentBasedFilter to work. Now, we'll decouple these components to allow for multiple types of filtering, such as a CollaborativeFilter. We'll use an abstract Filter interface with different implementations based on the selected filter type.

Spring makes this easy by automatically creating and managing the dependent instances for each component. It will automatically detect the dependency relationship between our classes, meaning you can focus on the code.

Your decoupled project will look like this:

package io.datajek.spring.basics.movierecommendersystem.lesson2;
import java.util.Arrays;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MovieRecommenderSystemApplication {
    public static void main(String[] args) {

        //SpringApplication.run(MovieRecommenderSystemApplication.class, args);
        //passing name of the filter as constructor argument
        RecommenderImplementation recommender = new RecommenderImplementation(new ContentBasedFilter());    

        //call method to get recommendations
        String[] result = recommender.recommendMovies("Finding Dory");

        //display results
        System.out.println(Arrays.toString(result));
    }
}

package io.datajek.spring.basics.movierecommendersystem.lesson2;
public class CollaborativeFilter implements Filter{
    public String[] getRecommendations(String movie) {
        //logic of content based filter
        return new String[] {"Finding Nemo", "Ice Age", "Toy Story"};
    }
}

package io.datajek.spring.basics.movierecommendersystem.lesson2;
public class ContentBasedFilter implements Filter{
    public String[] getRecommendations(String movie) {

        //implement logic of content-based filter

        //return movie recommendations
        return new String[] {"Happy Feet", "Ice Age", "Shark Tale"};
    }
}

package io.datajek.spring.basics.movierecommendersystem.lesson2;
public class RecommenderImplementation {
    //use filter interface to select filter
    private Filter filter;

    public RecommenderImplementation(Filter filter) {
        super();
        this.filter = filter;
    }
    //use a filter to find recommendations
    public String [] recommendMovies (String movie) {

        //print the name of interface implementation being used
        System.out.println("Name of the filter in use: " + filter + "\n");
        String[] results = filter.getRecommendations("Finding Dory");

        return results;
    }
}

package io.datajek.spring.basics.movierecommendersystem.lesson2;
public interface Filter {
    public String[] getRecommendations(String movie);
}

Advanced Spring concepts to learn next

Congratulations on completing your first decoupled Spring application! As you continue learning more advanced Spring concepts, try returning to this project and implementing more intricate filters and features. This will help you solidify your learning and give you a portfolio-ready project by the time you're ready to interview.

Some new concepts to apply to this project are:

Implement advanced autowiring
Optimize resource management with bean scope
Convert to a web application using Spring Web MVC framework
Create self-repairing systems using the BeanFactory design pattern
Add relational database support with Hibernate templates and Java Persistence API (JPA)

To help you learn these concepts and apply them to this project, Educative has created The Complete Guide to Spring 5 and Spring Boot 2. This course walks you through all the advanced features of Spring Framework and shows you how to use each in a project setting. By the end, you'll have hands-on experience with all of these topics and have the Spring context you need to thrive in an interview.

Continue reading about Spring and Java

Bytesize: 2 Accidental discoveries that changed programming

Ryan Thelin — Fri, 30 Apr 2021 20:55:24 +0000

Bytesize is our 5-minute infusion of developer history, speculation, or otherwise fun knowledge that you can enjoy during a work or study break.

When you set off to become a developer, you probably dreamed of working on self-driving cars, artificial intelligence, world-changing apps, or any number of other amazing products. However, there's a lot of learning and beginner developer work you need to do before you can get there. This can be draining and can make you lose sight of what got you excited to be a developer in the first place.

When knee-deep in a tough concept or a product function that's fighting back, Bytesize is here every week to give you 5-minutes to shake it off and let your imagination fly once more.

Never miss Educative content again

Learn more about our Newsletter

Chaos Engineering

Chaos Engineering is a form of stress testing that intentionally breaks your system or components under certain stresses to determine potential outages, locate weakness, and improve resiliency. Chaos Engineering is now used across large-scale tech companies to catch unpredictable situations, traffic levels, or unexpected race conditions.

While gaining prominence now, it was famously invented by accident by Netflix in 2011. Between 2008 and 2011, Netflix was looking for a replacement for their on-premise server after a critical and unexpected error.
Teams analyzed every part of the system trying to understand how the failure had occurred, why it had affected so much, and how they could prevent it in the future. Afterward, many engineers found that they had a much better understanding of the system they'd be using for years.

They settled on an AWS distributed cloud architecture with many interworking components. The switch solved the major error they had encountered but introduced a new level of complexity that they had to explore.

To learn more, the team considered how much they had learned about their system trying to troubleshoot the on-premises just a few years prior. They decided to create a program called Chaos Monkey that would randomly shut down components of the system.
Chaos Monkey allowed them to test if the services they were building were robust and resilient enough to deal with the unexpected errors that result from such large-scale products.

The practice would become known as "Chaos Engineering" and Chaos Monkey was released as open-source software in 2012. It has since gained traction as an essential process for proactively correcting distributed, at-scale systems.

From one critical error, Netflix was able to realize both the need for more resilient systems and found that frequent failure aversion was the key to truly understanding their system. They may not have intended it, but that one system failure in 2008 managed to lead developers down a whole new path of testing.

Java for web development

To understand this discovery we have to understand the state of computer science when Java was created.

In the late 1980s and early 1990s, there was a large boom in computer science innovations when many started to recognize the varied applications of computers. One innovator named Patrick Naughton at Sun Microsystems was particularly interested in cross-device communication using a computer. The dream was to make what we'd now call a smart remote to control multiple appliances in your home with the same device.

Both C and C++ were prevalent at the time but had a severe problem with cross-device code. Each compiler at the time would compile code to machine code only usable by the device it was compiled on. In other words, a C++ project compiled on a Macintosh computer couldn't be used by another type of device.

They needed a new programming language that could work on many devices, so the team created Oak, which would eventually become Java. Oak was different from other languages of its time because it compiled, not into machine code, but into an intermediate language called bytecode. Any device with a bytecode interpreter could then translate this into its own machine code and run the program.

Unfortunately, the original remote device failed to interest customers because most homes only had a handful of devices at that time. It was decided that there was little need for cross-device code and the project was scrapped.

However, in 1993 the first Mosaic browser was released and the World Wide Web began to take off. Suddenly, there was a network that connected devices of all types, and the need for cross-device code skyrocketed. Sun Co-founder, Bill Joy, realized that Oak's bytecode was a perfect fit for sending programs to the many devices on the web. The project was quickly adapted to suit the web and by 1995 Naughton had produced HotJava, a bytecode interpreter compatible with any browser.

Using Java and HotJava, developers could produce a program and release it to any web-capable device without having to consider which devices would access it. Java is still used in web development today to create enterprise-scale dynamic web applications with Java Enterprise Edition (JEE) and JavaServer Pages (JSP).

It's amazing to think that this language with cross-device properties seemingly tailor-made for web development was created before the web even existed -- to run a simple remote control!
It just goes to show that no matter how mundane the project seems, you might discover the next world-changing technology.