DEV Community: Jacqueline Wisdom

Intro to Ruby

Jacqueline Wisdom — Sun, 27 Aug 2023 17:32:10 +0000

Are you considering learning Ruby? Before you jump in, let's take a look at some of the basics of Ruby. It's history, it's design, and a brief look at the code will help any Ruby-beginner better understand the language, and decide if Ruby is the language for them.

A Brief History

Ruby was created in 1993 by Yukihiro Matsumoto. The creation of Ruby was heavily influenced by Perl and Python. Although both are object-oriented languages, Matsumoto felt that the object-oriented aspects of these languages were more of an after-thought. He set out to create a language that was object-oriented in it's core design. Thus, he created Ruby.

Matsumoto also designed Ruby with usability and simplicity in mind. He created Ruby with the intention of creating the best experience for developers. Rather than focusing on designing Ruby to best interact with the computer, his focus was to make a language that best interacted with the human using it.

I hope to see Ruby help every programmer in the world to be productive, and to enjoy programming, and to be happy.

-- Yukihiro Matsumoto

In 2005, Ruby on Rails was released. This web development framework had a huge impact on the popularity of the language overall. Rails made it easier and more feasible for many people to create their own web applications with Ruby, including small businesses and startups. After Rails was released, the usage of Ruby took off.

For almost two decades now, Ruby has remained a popular programming language. It had been used to create many large websites, such as Github, Airbnb, Hulu, and Shopify. Although it's usage has decreased somewhat in recent years, Ruby remains consistently in the top 10 most popularly used languages.

What is Ruby?

Ruby is a dynamically typed, object-oriented, interpreted programming language. Let's break all of that down into plain English.

Ruby is dynamically typed as opposed to statically typed. This means that types are checked at runtime. This may allow developers to write less code and for interpreters to load new code dynamically. For reference, examples of other dynamically typed languages include Javascript and Python.

Ruby is an object-oriented language, meaning it's design is organized around objects and data. Moreover, everything in Ruby is considered an object. Strings, integers, and booleans are all considered objects.

Finally, Ruby is interpreted rather than compiled. Another program interprets the language and executes instructions, rather than the target machine.

A Look At Ruby

Let's get a feel for Ruby by writing some basic code. Since Ruby is heavily object-focused, I will demonstrate how to make a class constructor to create many like objects.

class Cat
  def
    initialize(name, color)
    @name = name
    @color = color
    @ranking = 'the best cat ever'
  end
  def prnt
    puts "This is #{@name}, he is #{@color} and he is #{@ranking}!"
  end
end

Here, we use the class keyword to create a new class of Cat objects. The def keyword lets Ruby know that you are defining a method. In particular, we first use initialize to set some default values for our objects. We want to give every cat object default values of name, color, and ranking. In Ruby, the @ symbol is used to create an instance variable.

Next, we create another method called prnt. To keep the demonstration simple, all this method will do is print a sentence about my object. We could use the print keyword to print any following code. Instead, we will use puts, which also prints any following code, but with a built-in line break at the end.

In our sentence, we use string interpolation to refer to our object variables. For those who are familiar, this is comparable to template literals in ES6.

Now that we have our Cat class created, let's create some new instances of cat objects.

cat_one = Cat.new('Dr. Chocolate', 'brown')

Here, we create a new variable cat_one. Note that declarative keywords are not used in Ruby. Rather, the casing of the variable determines it's type. cat_one is lower-case, therefore it is not constant and can be re-assigned.

If we want to create a constant variable, we can use an upper-case variable name.

CAT_TWO = Cat.new('Mr. Mustard', 'orange')

CAT_TWO is a constant variable and cannot be reassigned.

Now that we have created some cat objects, we can access their methods. Let's use the prnt method to print descriptive sentences about our objects.

cat_one.prnt
# => This is Dr. Chocolate, he is brown and he is the best cat
# ever!
CAT_TWO.prnt
# => This is Mr. Mustard, he is orange and he is the best cat 
# ever!

Conclusion

In conclusion, Ruby is a general purpose programming languages used for many things, most often used for building web applications. Ruby has a strong online community because of it's long-held popularity. Because of it's simplicity, Ruby is a good language for beginners to learn. Additionally, it is especially intuitive for programmers who have prior experience with another language.

Sources

SSH Attackers VS Honeypots

Jacqueline Wisdom — Mon, 14 Aug 2023 04:46:00 +0000

The following is a classic tale of good versus evil.

Ever since the advent of networking technology, there have been malicious parties trying to intercept the private and valuable information that it transports. All sorts of networking technologies are regularly targeted by attackers, with many attacks carefully tailored to that technologies' weaknesses.

But as attacks become more deceptive and sophisticated, so does cybersecurity. In this blog, I will hone in on SSH attacks and SSH honeypots used to counteract these attacks.

What is SSH?

SSH stands for Secure Shell. An SSH allows users or administrators to securely access or control another computer remotely.

Before SSH, Telnet protocol was the leading technology used to for communication between computers across long distances. Telnet allows for two-way communication between a client and server via command line interface. However, any information transported using Telnet is easily intercepted by hackers.

SSH was introduced as a secure alternative. All information passed between computers using SSH is encrypted. Even if information transported via SSH is intercepted, is protected because of the encryption. Because of this useful security, many developers now favor SSH instead of Telnet.

Is it really secure? SSH Attacks

Unfortunately, as cybersecurity techniques and practices advance, so do those of attackers.

SSH shells are not completely air-tight or infallible, and can be the subject of brute-force attacks. SSH doesn't have a built-in mechanism to stop malicious parties from spamming commonly used username and password combinations until the shell is broken into.

There are many approaches to preventing SSH attacks. Developers can manually adjust their SSH settings to limit authentication attempts, use third party security tools to monitor and block repeated attempts, or implement two-factor authorization. These are all ways of blocking SSH attacks.

What is a honeypot?

Although the above approaches are all good practice, perhaps the most fun approach is fighting deception with deception.

A honeypot is a system used to deceive attackers. Honeypots are designed to appear to be vulnerable computers or networks, in order to entice hackers into attacking them.

In reality, honeypots contain no real valuable or private information for the hackers to access. Instead, their real purpose is to alert the honeypot owner of malicious activity, waste the hackers time or resources and, most importantly, gather information on how hackers operate.

SSH Honeypots

There are numerous open-source honeypots already created online, for various kinds of technologies. All the different features of honeypots are clever, inventive and amusingly diabolical. To illustrate these epic features, let's take a look at the following SSH honeypots.

Kippo

Kippo is a medium interactive honeypot that engages and responds to attackers. Although Kippo is older and somewhat dated, it has great features and is a good illustration of the inventive ways honeypots can be used to troll attackers.

Kippo emulates a real shell and has an entire fake file structure, to convince attackers that they have broken in. Attackers can cd into, create and remove files. Kippo also has a fake disconnect feature, where hackers can ctrl + d "out" of the shell. Kippo only pretends to disconnect, but really stays connected to continue impeding the efforts of the hacker.

Perhaps the greatest feature of Kippo is that it logs the entire attack. Every command entered by the attacker is logged and the owner of the honeypot can view the interaction at any time.

Above is a Kippo honeypot foiling an attacker. For your entertainment, here is the full log of Kippo VS a real SSH attack.

Hellpot

Hellpot is an endless honeypot that sends a never ending stream of data to the attackers. The data is intentionally created to look like real data from a website, so that hackers will sink their time and or resources into the attack.

But the data stream will never end, and there is no real private information to be stolen. In reality, the data is generated from random chunks of The Birth of Tragedy (Hellenism and Pessimism) by Friedrich Nietzsche; a covert nod to the fate of the hackers, who will be left questioning their choices and even their very existence.

T-Pot

Finally, there is the powerful and awe-inspiring T-Pot. T-Pot is a platform that includes over 20 different honeypots and dashboards that give detailed information about any incoming attacks.

These dashboards have an array of cool features: word clouds of your hackers most frequently used username and password combinations, lists of your hackers IP addresses, and world maps that visualize the location of your attackers in real-time.

Conclusion

In conclusion, honeypots are one of the many approaches one can take in dealing with the ongoing threat of cyber attacks. Honeypots can be made for almost any kind of tech that attackers target. They allow us to not only waste the time and resources of attackers, but also gather valuable information about the techniques that attackers use, in order to better protect against such attacks in the future.

Sources

Intro to Kubernetes

Jacqueline Wisdom — Mon, 31 Jul 2023 01:29:18 +0000

What is Kubernetes?

Kubernetes is an open-source platform through which developers can manage, deploy and maintain groups of containers. Applications can be made up of hundreds of containers, all of which need to be managed. Additionally, these containers may need to be managed across different environments: physical machines, virtual machines, cloud environments, or even hybrid environments. Managing such containers without a container-orchestration technology would be an exceedingly complicated task.

To address this problem, in 2003, developers at Google created the Borg system. The Borg system is the predecessor of Kubernetes. Kubernetes was then created in 2014 as an open-source alternative to the Borg system. Today, Kubernetes is the most widely-used container management tool.

How does it work?

The structure of Kubernetes is divided into discrete components, each responsible for different things. Generally, there are Master Nodes, responsible for higher-order management, and Worker Nodes, responsible for running the applications.

Master Nodes

Master Nodes contain many important subcomponents that handle the greater management of the cluster. Firstly, there is an API server, which functions as an entry point to the cluster and handles requests. Next, there is a controller manager, which keeps running tabs on the state of all components in the cluster. If a component fails and needs repair, the controller manager will detect the failure and handle the repair.

Additionally, the Master Node contains the scheduler. The scheduler takes inventory of the available resources on the worker nodes and determines where incoming containers will go. Finally, the Master Node also houses the etcd key-value storage. The etcd has all the configuration data and status data of each node and of each container it holds. Backups are created from snapshots from the etcd. These snapshots give the Master Node the ability to recover any container or node in the cluster.

The Master Nodes are arguably the most important. They have the ability to restart or restore any part of the cluster that fails or is lost and are responsible for the greater functioning of all other nodes and containers. Worker Nodes, alternatively, tend to be larger and have the most load. This is because Worker Nodes are responsible for running applications.

Worker Nodes

Just like Master Nodes, Worker Nodes are made up of several different components. Each component is responsible for different functions. Firstly, each Worker Node has a kubelet process. The kubelet allows communication between the nodes. If there is a problem with the status of it's Worker Node, the kubelet relays this message to the Master Node, receives instructions and carries them out.

Worker Nodes also contain any number of containers. A container is a single component of packaged up code and any needed dependencies. A popular container technology, often used in tandem with Kubernetes, is Docker. There may be a different number of containers in each Worker Node, depending on the distribution of the load.

Kubernetes Usability

Kubernetes is currently the most popular container management tool. However, before deciding on whether to use any technology, developers should assess it's usability and benefits, as well as its challenges.

Pros

Scalability: As load increases or decreases, Kubernetes can quickly scale accordingly. It can manage a wide range in number of containers and can automatically add nodes to clusters as needed.
Disaster recovery and self-healing: if a disaster occurs and data is lost, there are backups saved and all data can be restored.
Load balancing: containers are sorted into nodes after an automatic assessment of each nodes available resources.

Cons

Complexity: Kubernetes is a complex technology and is not beginner friendly. It takes a minimum level of expertise to use Kubernetes, and those who do often must be explicitly trained to do so.
Not practical for small applications or startups: Kubernetes' ideal use is managing large groups of containers for complex applications. It may not be particularly useful depending on the scale of an app.

Conclusion

In conclusion, Kubernetes is a popular, open-source technology that is widely used to manage large numbers of containers. It is comprised of separate, hierarchal components that control specific aspects of functioning. It is an ideal tool for complex applications.

Works Cited

Behavior Driven Development

Jacqueline Wisdom — Mon, 26 Jun 2023 16:55:18 +0000

Intro

Behavior driven development (BDD) is an outside-in approach to software development that promotes understanding in all members of a team. In order to understand BDD, one must first understand test driven development (TDD). BDD takes the general TDD approach, and adds an additional layer of guidance to further flesh out a concrete plan of action. One of the benefits of BDD is that this approach will aid intra-team communication, and thereby streamline efficiency of software development projects.

What does TDD have to do with BDD?

These two approaches are not mutually exclusive. In fact, BDD emerged from TDD. TDD, on it's own, is a powerful and effective approach to software development that has changed the way developers implement code. BDD takes this approach and elaborates even further.

What is TDD?

Test-driven development is a process in which tests are created before code is implemented. First, developers write tests against which they will test their code. These tests are written before the code and therefore should initially fail. Code is then subsequently implemented with the goal of making the tests pass. Thus, development is driven by the tests.

How BDD Works: Outside-in

BDD takes the TDD approach and adds a few more layers of specified action.

Narrative

Starting at the top, team members can articulate their goals in the "narrative" phase. At this time, team members use natural language in a specific structure to describe the goals of their software project. That structure is as follows:

As a (person's role)
I want (desired feature)
So that (benefit/value)

A product owner will use this structured, natural language to articulate a narrative of how their want their product to work. For example, suppose the owner of a grocery store is implementing on online shopping service for grocery delivery. They want customers to be able to view grocery items, add selected items to a cart, and check out. They might articulate the following customer narrative:

"As a grocery store customer, I want to add a desired items to my cart, so that I can purchase them."

Using this natural language makes goals accessible and aids communication among the many members of the project's team, regardless of whether they are familiar with the technology. For example, designers, business owners and quality assurance can participate and communicate effectively.

Source

Acceptance Criteria

This structured narrative is then easily translated into clearly stated acceptance criteria. Acceptance criteria are the goals that must be achieved by the software. They are stated in the following structure: Given (initial context), When (event that will trigger a scenario), Then (expectation or outcome).

Source

To continue our online grocery service example, the acceptance criteria would be as follows: "Given that I am browsing items, when I click an item, the item should then be added to the cart."

Executable Tests

Now that we have broken down the goals of our software in plain, understandable language, we can translate them into actual tests against which to test our code. Tests should be given descriptive names of whatever behavior they are testing for. Using test methods named actual descriptive sentences helps developers create documentation that everyone on the team can understand.

Here is an example of what some of the tests may look like:

class AddItemToCart extends TestCase {

testAddItemToCollection() {
    …
};

testIncreaseItemCount () {
    …
};

testIncreaseTotalPrice () {
    …
};

(... and so on)
};

Now we all team members have been able to contribute thoughts and ideas. Developers are now able to use all of this information to hone in on features of the software, and create specific tests.

Conclusion

In conclusion, BDD is a helpful, top-down approach that provides clear structure of how to achieve particular software features. The natural language allows all of the necessary parties to contribute to the project. The structure provides straightforward guidance on how to articulate goals, and how to proceed at each step. Finally, developers can get down to the detailed level of TDD, and implement their code against tests.

Sources

Intro to Python

Jacqueline Wisdom — Sun, 18 Jun 2023 22:09:08 +0000

A Brief History

Python was released in 1991 by Guido Van Rossum. During team meetings in the early days of Python, the title "Benevolent Dictator for Life" was bestowed upon Van Rossum. This venerable title has since been reserved for only a small group of giants of the open-source software development world.

History, BDFL

GVR

And in case you were wondering: Yes, the Python programming language was named after Monty Python, the British comedy sketches. Because, with Python, coding is fun!

Python name

MP meme

Python was created with usability, efficiency and simplicity in mind. Python developer Tim Peters expands on this mindset with the "Zen of Python" ...

"Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Readability counts."

Zen of Python

What is Python, anyway?

Python is a multipurpose, server-side programming language that is rapidly gaining popularity. It's known for its ease of use, versatility and vast array of libraries. Python is used by Youtube, NASA, Pixar, Netflix and Facebook-- just to name a few. It is one of the top programming languages that developers use, are currently learning, or are requested to know by potential employers.

Companies using Python, Stack Overflow Ranking, jetBrains Ranking, PYPL ranking

Python is known for it's ease of use. The syntax and grammar of Python are specifically designed to be as straightforward, intuitive and concise as possible. It is often recommended as the first programming language to learn for beginners. And, it is especially easy to pick up for developers that have familiarity with other languages.

Python is also known for it's versatility . It has great extensibility and versatility because of its modules. Extensibility is how much a framework can extend to another system and how easy this is to implement. There are many different modules, libraries and packages that can be used with Python. Whatever it may be that you want to build with Python, there is most likely already a built-out foundation for it.

What does it look like to code in Python?

Now that you know all about it, let's see what it's like to actually code with Python. Here's a small astrology program, named Bob, that will ask for a user's birthday, and respond based on that information.

# Let's build an astrology program!

# print a greeting
print('Hello astrologer!')
# ask user for name
print('What is your name? ')
# assign user name to a variable
my_name = input()

The print() method will print any value passed into it. Here, we print a greeting and ask for a users name. At this point, we can assign a variable to input(), and whatever the user inputs will be saved as their name.

# app introduces itself
print('Hi ' + my_name + '! My name is Bob.')
print('My birthday is 06/18/2023. That means I am a Gemini!')
# ask user for birthday
print('When is your birthday? (Please input in this format: 00/00/0000) ')
# assign user birthday to variable
my_birthday = input()

Now, we have our users birthdate information. But, anything passed into input() will automatically be stored as a string. To use this data in the form of a number, we'll have to convert the datatype.

We can use the int() method to convert a string to an integer. We also only need certain positions from the input in order to determine the user's birthday and month. We can use bracket notation to access particular values of the input, based on their indexes.

# create month and day variables
my_month = int(my_birthday[0:2])
my_day = int(my_birthday[3:5])

Now we have stored the users birthday information data as numbers, and can use it as such.

# determine user's sign based on month and day variables
if my_month == 1 and my_day < 20 or my_month == 12 and my_day > 21:
    my_sign = 'Capricorn'
elif my_month == 1 and my_day > 19 or my_month == 2 and my_day < 19:
    my_sign = 'Aquarius'
elif my_month == 2 and my_day > 18 or my_month == 3 and my_day < 21:
    my_sign = 'Pisces'
elif my_month == 3 and my_day > 22 or my_month == 4 and my_day < 20:
    my_sign = 'Aries'
elif my_month == 4 and my_day > 21 or my_month == 5 and my_day < 21:
    my_sign = 'Taurus'
elif my_month == 5 and my_day > 22 or my_month == 6 and my_day < 21:
    my_sign = 'Gemini'
elif my_month == 6 and my_day > 22 or my_month == 7 and my_day < 23:
    my_sign = 'Cancer'
elif my_month == 7 and my_day > 24 or my_month == 8 and my_day < 23:
    my_sign = 'Leo'
elif my_month == 8 and my_day > 24 or my_month == 9 and my_day < 23:
    my_sign = 'Virgo'
elif my_month == 9 and my_day > 24 or my_month == 10 and my_day < 23:
    my_sign = 'Libra'
elif my_month == 10 and my_day > 24 or my_month == 11 and my_day < 22:
    my_sign = 'Scorpio'
elif my_month == 11 and my_day > 23 or my_month == 12 and my_day < 22:
    my_sign = 'Sagittarius'

These statements are known as conditions. Depending on the conditions of the users birthdate data, we can assign a variable to store the appropriate sign.

# respond with user sign
print('You are a ' + my_sign + '! I knew you were crazy.')
print('Wanna know your moon and rising?')
answer = input()

if answer == 'yes':
    print('Please enter your birth time and location!')
else:
    print('Typical ' + my_sign + '. Whatever!')

There you have it! In just a few moments, we've created a program that takes in data about a user and responds based on that data.

How does Python stack up to other languages?

Pros

Usability: Python is easy to learn and use, and is quite powerful considering.
Extensibility: Python has many different libraries to support different kinds of applications.
Community: Python has a large community with many resources available online. This may be especially important for beginners.
Scalability: Python is can be used for small, simple apps or it can be used for large projects by big companies.
Great for backend: Although Python is a general language, it is particularly useful for backend. Data science, automation, machine learning and AI are all areas of strength for Python.

Pros of Python,
More Pros of Python

So far, we've only looked at the advantages of using Python. As it is a popular language, it's no surprise there are so many.

But, just like any programming tool, there are upsides and downsides. In the case of Python, there are aspects of it that may not be ideal for a given developer, depending on their specific goals.

Cons

Possibly too general: while in many ways this is an advantage of Python, it can also be a disadvantage. Sure, you can build pretty much anything with Python. But just because you can, doesn't mean you should. In particular, Python is weaker than other languages when it comes to mobile apps and 3D rendering. If your goal is build a game, mobile app, or website, Python may not be the best choice. Other languages are more specialist than Python, and may be a better choice for one specific project.
Slowness: Python is dynamically typed, and as such, it is read slower. It has a "global interpreter lock", meaning that only one thread of code can by read by the interpreter at a time. While this difference in speed may not be particularly dramatic compared to other languages, it is something to consider.

Conclusion

In conclusion, there are many advantages to Python. It is versatile, intuitive and in high demand. If you are planning to work in data science, automation or machine learning, it may be especially great to use. Otherwise, if you are planning to work in an area that would be better suited by another specialized programming language, you can always focus on one language now and learn Python later on. For a software developer, Python is a great skill to have in your repertoire.

Ready to get started? Here's a few simple exercises to help you dip your toes into Python.

Intro to Heroku

Jacqueline Wisdom — Sun, 11 Jun 2023 18:05:59 +0000

So, you want to build an app.

In order to get your app up and running, you'll need to deploy it somehow. You might consider Heroku-- a popular deployment platform.

What is Heroku? Should I use this deployment platform? What is a deployment platform? What is deployment?

Let's take a look.

A Brief History of Heroku

Heroku was founded in 2007 by James Lindenbaum, Adam Wiggins, and Orion Henry.

Fun fact: the name “Heroku” was created by combining the words “hero” and “haiku.” This is an homage to Japanese programmer Yukihiro Matsumoto, creator of the Ruby programming language (and all-around cool guy).

Heroku name origin

Matz image

Originally, Ruby was the only programming language that Heroku supported. Since its origin as one of the first ever cloud platforms, Heroku has continually grown and adapted. It now supports many programming languages and has been used to create over 13 million apps. Wow!

13 million apps

What is Heroku, anyway?

Heroku is a cloud platform that developers use to deploy applications. Deployment is the process of releasing an app and making it available to users on their devices.

To make this possible, applications need infrastructure. There are many components that make up that infrastructure: web servers, application servers, storage servers, firewalls, and so on. Heroku streamlines this process for developers. It can help save time, and ensure that applications run smoothly across all systems.

App infrastructure

App infrastructure image

As was mentioned before, Heroku supports an array of programming languages. This includes Ruby, Java, Node.js, Python and Clojure-- just to name a few.

Supported languages

For any language not officially supported by Heroku, there are buildpacks. A buildpack can be created by any user to support any language or framework not already covered by Heroku. Most likely, for any given framework or language a developer may want to use, such a buildpack has already been created.

Heroku buildpacks

How does it work?

Developers can create their application by using the command “heroku create”, followed by the app name, in the terminal. At this time, Heroku creates an empty container in which the code can run. Heroku provides a link to a live, working version of the app that the developer can use to test out their code.

To deploy, developers push code into Heroku with the command “git push heroku main.” Heroku then performs several actions on the code and packages it into a new release. Every push creates a new release, so all earlier versions of the app are preserved. Now the app is (in theory) production ready!

Heroku commands

As developers delve deeper into Heroku, there are many other actions they may want to perform. Here is a useful cheat sheet of Heroku commands.

Heroku cheat sheet

(Note that this cheat sheet contains "git push heroku master" as the deployment command. As of 2020, Heroku also supports "main" in place of "master" as the primary branch.)

After deploying, developers can use the many tools and add-ons Heroku provides to keep the app running smoothly. Heroku is also known for its ease of scaling; as the app grows, and as does the number of it's users, developers can simply use a drag slider to increase scale.

So what's the scoop?

Pros

There are other options for cloud platforms. So why use Heroku? According to Stackshare, "https://stackshare.io/heroku", the following are the three most highly reported pros of Heroku:

Easy deployment
Time efficiency
Simple scaling

Cons

Previously, one of the biggest advantages of Heroku was that it was free. However, as of 2022, Heroku no longer provides a free tier. In his blog post, "https://blog.heroku.com/next-chapter", general manager Bob Wise cited an “extraordinary amount of effort to manage fraud and abuse of the Heroku free product plans.”

Thus, a noteworthy con of Heroku is the cost. The elimination of the free tier was not well received among many users.

On his YouTube channel, "https://www.youtube.com/watch?v=prjMJtXCR-g", Theo Browne, CEO of Ping, put it bluntly: "Heroku is dead." He states that "Heroku is no longer viable, by their own decisions and definitions, as a way to get started on a new app."

RIP Heroku image

The takeaway form this change? In stark contrast to it's history, Heroku may no longer be ideal for small businesses or start-ups.

Conclusion

In conclusion, Heroku is a long-standing platform known for it's ease of use. It can help developers get their apps off the ground and ready for users. It streamlines the process of deployment as well as maintenance. And, it can do this with mostly any favored programming language of the developer.

Depending on your situation, Heroku may or may not be the right choice for you.

Want to learn more about Heroku? Helpful links:

"Introduction to Heroku" video by Salesforce, with overview and live demo: https://www.youtube.com/watch?v=QTOkqzCTGxw
"What is Heroku" episode of Dylan Israel's "Ask a Dev" Series: https://www.youtube.com/watch?v=r5ZUQvl9BtE
About Heroku Buildpacks: https://www.heroku.com/elements/buildpacks
About Heroku Add-ons: https://www.heroku.com/elements/addons

Saying "No" to Heroku? Alternatives:

Javascript Functions

Jacqueline Wisdom — Thu, 04 May 2023 22:23:46 +0000

Function Declaration and Calls

Functions are reusable blocks of code that take an input value, perform an action, and return an output value. The basic syntax of a Function Declaration is:

 function add (num1, num2) {
      return num1 + num2
 }

This is a Function Declaration. Functions are declared with the keyword function, followed by the function name. Then, the parameters, or input values, follow the function name in quotes. Following the parameters, is the function action wrapped in curly brackets. In this case, the function is named 'add', takes in two parameters: 'num1' and 'num2', and the action is to return the value of these two parameters added together.

Functions can also be declared as Function Expressions. The syntax of a Function Expression is:

 var add = function(num1, num2) {
      return num1 + num2
 }

In a function expression, a variable is assigned to a function with an assignment operator. One important difference in whether a function is defined in a declaration or an expression is that entire function declarations are hoisted to the top of the code-- the name and the body. Function expressions, however, only have their names hoisted to the top. The function body is not hoisted along with the name.

A function is evoked with the function named followed by parentheses.

add(1,2) //=> 3

In this case, 1 and 2 are the 'arguments' passed into the function. When 1 and 2 are passed in, the function will return their sum and the invocation resolves to 3.

A more concise way of declaring functions is using arrow functions.

var add = (num1, num2) => num1 + num2

Arrow functions indicate a function while skipping the keyword 'function' entirely. They are declared by assigning a variable to the function parameters, followed by an arrow, followed by the action. In this case, since the action is only on one line, the curly brackets and the return statement can also be omitted.

Anonymous functions are functions declared without a name. They are usually written when being passed through other functions.

function alterNum(num, func){
     return func(num)
};

alterNum(1, function(num){return num * 10})
//=> 10

The function that was passed unto alterNum is an anonymous function.

Functions and Scope

Functions can access values from the parent scope.

     var firstName = 'Jackie';
     var lastName = 'Wisdom';

     function createName(){
        let fullName = firstName + ' ' + lastName
          return fullName
        }

     console.log(createName());//=> 'Jackie Wisdom'

In the above example, the createName function has access to variables created in the parent scope, outside of the function scope. However, variables created inside of a function are function-scoped; they cannot be accessed outside of the function.

     var firstName = 'Jackie';
     var lastName = 'Wisdom';

     function createName(){
         let fullName = firstName + ' ' + lastName
          return fullName
         }

     console.log(fullName)//=> Reference Error: fullName is not defined

In the above code, logging fullName to the console will result in an error. This is because fullName was created inside of the createName function, and therefore cannot be referenced outside of this function.

Functions are capable of closure. This means they can contain references to variables in their parent scopes.

     function makePizzaOrder(customer, total){

     var toppings = [];

     return {
     customer: customer,
     total: total,
     addToppings: function(top1, top2){
     toppings.push(top1, top2)
              }
     getToppings: function(){
     return toppings;
             }

         }
     };

     var order1 = makePizzaOrder('Bob', 20.00);
     order1.addToppings('cheese', 'pepperoni');
     console.log(order1.getToppings()); //=> ['cheese', 'pepperoni']

The above is an example of closure because the functions inside of the makePizzaOrder function refer to the toppings array, which was created in the parent function. The toppings array is not available outside of the makePizzaOrder function, but, because of closure, it is kept alive.