DEV Community: Cody Daigle

Elixir LIbraries

Cody Daigle — Mon, 24 Jun 2024 06:04:58 +0000

One of my favorite things about software development is that you can never grow bored or know too much. There is always something that pulls me in deeper and deeper and lately that has been Elixir. I have written two other blogs going over the strengths of Elixir and how Erlang’s Virtual Machine(The BEAM) works well with Elixir. Elixir is made up of six applications and I’m continuing this journey with a breakdown of what Elixir is and it's three libraries.

What is Elixir?

A dynamic, functional programming language designed for building scalable, maintainable applications, leveraging The BEAM, which is known for its fault-tolerant, concurrent, and low latency systems. Needless to say, it's a go-to choice for a large range of applications that aim to benefit from its productive tooling and extensible design.

Web Development

due to it being a powerful tool for building web applications, especially ones such as chat applications, online games, applications that require live updates, and other real-time features.

Distributed

Elixir runs on Erlang’s virtual machine, which was specifically designed for building not only fault-tolerant systems but to also be distributed, which is perfect for applications that require distribution across multiple nodes

Concurrency

First-class support for concurrency making it a excel with applications that require high levels of concurrency like mulit-user applications or applications with high simultaneous connections.

Embedded Systems

Can be used to write firmware for devices and its concurrency model and fault-tolerance fits in nicely with this domain.

Data Processing

Handles large volumes of data and concurrency support making it solid for data processing tasks.

Telecommunications

Elixir is a descendant of Erlang, which was originally designed for telecommunication systems, making it fit in naturally with these applications/systems.

Blockchain

Continuing on the scalability and fault-tolerance, Elixir is also used for developing blockchain technologies.

Elixir's Standard Library

The standard library in Elixir provides a set of modules and functions that are available out of the box for Elixir developers. It’s loaded with a wide range of functionalities that aid in alleviating common programming tasks.

Enum: Provides a set of algorithms that enumerate over enumerables based on the Enumerable protocol.
map, reduce, and filter

String: Provides functions for working with strings, like string manipulation, in Elixir.
length, replace, split

List: This module provides functions for working with lists.
delete, flatten, zip

Map: This module provides functions for working with maps.
get, put, keys

IO: This module provides functions for input/output operations.
puts, gets, inspect

File: This module provides functions for working with files.
read, write, ls

Process: This module provides functions for working with processes.
send, receive, alive?

GenServer (Generic Server Process): This module abstracts client-server interactions, making the creation of Elixir servers easier by automatically implementing a standard set of interface functions, including tracing and error reporting. With that part of the load taken care of all that is required from the developers is to implement the functionality they desire. Neat.

Agent: This module provides a basic server implementation that allows state to be retrieved and updated.

Task: This module makes running functions asynchronously and retrieving their results easy.

These modules and their functions form the backbone of many Elixir applications, which provide crucial functionalities for tasks like data manipulation, concurrent programming, file I/O, and more.

EEx: Elixir's Templating Library

Embedded Elixir(EEx) is a templating library, but still a part of the standard library. In Web Development it’s often used to generate dynamic HTML content allowing you to embed Elixir code in the HTML templates to create parts of the page according to data dynamically. You can generate dynamic HTML content and Elixir code dynamically, which is handy for those metaprogramming moments. Configuration files can also be generated dynamically based on either environment variables or conditions.

Here's a basic example of how EEx is used in an Elixir application:

# Define a template with placeholders
template = "Hello, <%= name %>!"

# Use EEx to evaluate the template with given bindings
message = EEx.eval_string(template, [name: "World"])

# Outputs: Hello, World!
IO.puts message

Here, <%= name %> is a placeholder with embedded Elixir code. When EEx.eval_string is called, the placeholder is then replaced with the value of name from the given bindings.

ExUnit: Elixir's Unit Test Library

ExUnit is Elixir's built-in testing framework which provides the ability to write unit tests and various features for teardown of tests*,* setup, and assertions. Testing is essential in software development for multiple reasons. Including correctness to ensure your code behaves as expected. Prevents regression by making sure, after modifying your code, you don’t break functionality that already exists. Aids in the design of your software, in turn helping you write more maintainable, modular code. And possibly the most important, in my opinion, is that it serves as documentation, showing those that look at your code, how your code is suppose to work.

defmodule MyApp.CalculatorTest do
  use ExUnit.Case

  test "add/2 returns the sum of its arguments" do
    assert MyApp.Calculator.add(1, 2) == 3
  end
end

We have our test module MyApp.CalculatorTest that uses ExUnit.Case. Inside, we define our test with the test macro. The test checks that the add/2 function of the MyApp.Calculator module returns the correct sum. To run the tests, you would typically use the mix test command in your terminal.

mix test

This will run all test files in the project’s test directory. This also allows you to specify individual test files or directories to run a subset of your tests, for example:

mix test test/my_app/calculator_test.exs

This will only run the tests defined in calculator_test.exs.

In conclusion, I'd like to say the benefits you gain when using Elixir, and all it has to offer, is fantastic. It makes me excited to keep working with it and learning so much more. I hope you learned as much as I did!

Elixir, Erlang, and the BEAM

Cody Daigle — Mon, 10 Jun 2024 03:29:22 +0000

It’s exciting to learn new languages, especially one’s you take an interest in, but a great rule of thumb when taking in that learning process is to understand where they originate from. So, before taking a deep dive into Elixir I’d say it’s a pretty solid Idea to look into Erlang, Elixir’s parent language, in order to properly conceptualize what occurs within Elixir. One important topic to delve into would be Erlang’s virtual machine and the vital role it plays when developing with the language.

Erlang

The Erlang development platform was created, in 1986, by Joe Armstrong, Mike Williams, and Robert Virding while at the Ericsson’s Computer Science Laboratory to aid in the development of telephony applications. Erlang is not only a platform but also a language. One of the large reasons Erlang is praised on it’s error handling is the use of the Open Telecom Platform framework. Although not so much on the telecom part, but instead is directed towards software that has properties of telecom applications, but i digress (I’ll touch on OTP a little later). Modern day systems require aspects like concurrency, fault-tolerance, and scalability in order to perform efficiently, preferable not crash at all, but when then inevitably do fail they recover swiftly. Now in a perfect world a system would be 100% bug and issue free, but sadly that’s not possible. Fortunately for us, by default, Erlang provides necessary assets to create systems with as much relief in those instances as possible. Next I want to go over how BEAM helps achieve this, but here are some of the resolutions that is provide by the use of Erlang/Elixir

Detects and recovers from errors with ease
Always provides a response regardless of the error so that it doesn’t affect the system impacting the user.
Can be updated without disrupting user activities
Can be distributed

BEAM me up

The impressive concurrency and scalability within Elixir/Erlang systems may seem like witchcraft, but all the code that you write is actually executed on Erlang’s VM, called BEAM (Bogdan / Björn’s Erlang Abstract Machine). The files that are run on the virtual machine are compiled into bytecode with the .beam extension. What makes the virtual machine truly worthy of the spotlight and deserves to be recognized due to it’s unique handling of responsibilities like managing concurrency and parallelism of a system. In situations like simultaneous data processing, BEAM shines by effectively managing these tasks, enhancing the system's productivity and efficiency. Additionally Beam excels in error handling, which is a crucial aspect of any system, and handles those errors with minimal impact. The picture I’m trying to paint is the excellence in handling concurrency and parallelism, its efficient resource utilization, and robust error handling and recovery mechanisms making it a highly reliable and available system.

OTP

Open Telecom Platform, commonly referred to as OTP, is an extensive collection of libraries and tools that form an integral part of the Erlang/OTP distribution. It provides a comprehensive framework that is specifically designed for the creation of robust applications that are not only fault-tolerant but also distributed in nature. This is all made possible through the use of the Erlang programming language, which is renowned for its ability to handle concurrent processes efficiently. Thus, OTP is a crucial tool in the Erlang ecosystem, enabling developers to build complex, reliable, and efficient applications with relative ease.

Applications - Packages and manages application’d dependencies, configuration, and startup / shutdown processes
Behaviors - Design patterns or abstractions for structuring applications
Debugging & Tracing - Erlang Debugger, Profiler, Trace tools
Distribution - Processes can run on different nodes and maintain transparent communication
Hot Code Upgrades - Upgrading code doesn’t cause down time. AKA Hot Swapping.
Libraries - Standard libraries for file handling, networking, and more
Supervisor Trees - Creates hierarchical process structures for monitoring child processes.

OTP plays a vital role in the Erlang ecosystem and Elixir inherits it’s features along side the BEAM.

Erlang and Elixir code are compatible, so either language can be written interchangeably. The main difference lies in Elixir's more accessible syntax and tooling, which allows for cleaner, more maintainable code with a short learning curve. Elixir, with its friendly programming language, welcoming community, and tons of helpful resources like documentation and tutorials, really lets you tap into the power of BEAM. You'll be able to whip up projects in no time and take full advantage of everything it has to offer!

Personally, I look forward to really having the opportunity to delve as deep as I can into Erlang and Elixir to become proficient with developing technologies. With that being said the next few items I intend to write about will be the Elixir framework, Phoenix, and some of the advantages with using the language like pattern matching!

Elixir: Strengths

Cody Daigle — Mon, 27 May 2024 03:49:46 +0000

In this article I plan to go over just a few of the strengths and advantages that the Elixir programming language has to offer. Applications today often have issues with scaling and concurrency and Elixir provides that solution. Large-scale sites and applications that you may be familiar with, such as Discord, Pinterest, and even PepsiCo, utilize these advantages.

What is Elixir?

Elixir is a robust, functional programming language, inspired by Ruby, excelling in Fault-tolerance capabilities, Scalability, and Concurrency, focusing on productivity and readability. Elixir prioritizes pure functions, higher-order functions, and immutable data, encouraging expressive, clear code writing. I mention robustness due to Elixir's utilization of a functional approach which provides clear, concise code, reduction of bugs, and upon
troubleshooting or debugging the problems are solved in small, testable units. Considering functions are treated as primary elements, or first-class entities, they are passed as arguments to other functions or returned as a result allowing strong composition and abstractions.

Strengths

Erlang's goal is to provide the ability to create highly available systems that run consistently and provide meaningful responses to client requests. But in order to achieve a highly available system you have to overcome fault tolerance, scalability, and distribution so that the provided service has minimal failures as well as downtime.

Elixir-in-action

Fault tolerance: Minimize, isolate, and recover from the effects of run-time errors.
Scalability: Handle a load increase by adding more hardware resources without changing or redeploying the code.
Distribution: Run your system on multiple machines so that others can take over if one machine crashes.

Concurrency

Elixir’s processes communicate asynchronously.
Concurrent operations are efficient and responsive.

Elixir is a concurrent language as well as a functional language. The concurrent characteristic allows you to improve the availability of your system and organize your runtime, whereas the functional portion allows clean and organized code. One of the major benefits to using Elixir is it's support for concurrency and thanks to Erlang's virtual machine (BEAM), and it's tools and techniques, this has been a central role in doing so.

Scalability

Elixir’s lightweight processes enable easy concurrency.

Scalability and concurrency is essential for Applications we use and build today. Elixir allows us to build applications where performance isn't compromised when dealing with large quantities of requests. Additionally, the distributed environment that Elixir provides allows applications to scale horizontally which is perfect for indulging rapid growth in businesses. Elixir's concurrency model gives developers access to create lightweight processes, called Actors, that communicate seamlessly with other processes via passing messages. And with that level of communication systems can scale over multiple nodes with ease.

Fault-Tolerance

Within BEAM, fault tolerance is a first-class concept that gives the ability to develop reliable systems. The ultimate concept of fault tolerance is to recognize failures while diminishing their impacts upon a system and it to recover without human interference. Now it's not to say that failures or bugs won't happen. In any complex system things can certainly go awry, whether it's hardware, components, bugs, or even the inability to cope with a large request rate. Luckily the failures that do occur are isolated and then managed to ensure that the system continues running, hence Erlang's philosophy of 'let it crash'.

Supervision Trees
A supervision tree is a hierarchical structure that contains a list of child processes it will manage using Supervisors. Supervisors are specialized processes that monitor other processes to ensure system resilience by forcing child processes to automatically restart when they happen to fail. The capabilities of managing the children processes are defined within the strategies you desire the supervisor to use. Currently there are three supervision strategies that supervisors have available to them.

one_for_one - Restart only the child process that terminated
one_for_all - In the event of a failure, restart all of the child processes.
rest_for_one - Restart the process that failed as well as any process that was started after it.

This is an example of what a Supervisor Tree would look like:

def start(_type, _args) do
    children = [
      worker(:root_worker),
      supervisor(
        :one_for_one,
        [
          worker(:worker_1),
          worker(:worker_2)
        ],
        name: :supervisor_1
      ),
      supervisor(
        :rest_for_one,
        [
          worker(:worker_3),
          worker(:worker_4),
          worker(:worker_5),
          supervisor(
            :one_for_one,
            [worker(:subworker_1)],
            name: :subsupervisor_1
          )
        ],
        name: :supervisor_2
      ),
      supervisor(
        :one_for_all,
        [
          worker(:worker_6),
          worker(:worker_7),
          worker(:worker_8)
        ],
        name: :supervisor_3
      ),
      worker(:transient_root_worker, :transient)
    ]

    # The root of the tree is a supervisor that runs everything we defined above
    opts = [strategy: :one_for_one, name: SupervisorSample.Supervisor]
    Supervisor.start_link(children, opts)
  end

Conclusion

I am still in the early stages of my software developer journey and I am always fascinated when it comes to learning new items the software world has to offer and Elixir has made it's way up into my list of next languages I'd like to learn in it's entirety. I hope this short introduction to some of Elixir's strengths intrigued you as much as it did me. I plan to continue my research with Elixir and Erlang and provide more information for those that are also interested in working with it.

Software Development Life Cycle

Cody Daigle — Mon, 22 Apr 2024 03:46:11 +0000

Within software development there lies a methodology for traversing through the stages of development. Each step plays a vital role to ensure good-quality software. These roles specify tasks that need to be performed, at different stages, by software developers or engineers. The ultimate goes is to ensure the roduct meets the expectations held by the customer and is within the overall budget. Prior knowledge of each stage and what each one demands is important when undergoing the software evelopment process.

How Many Phases are in the SDLC?

In my research I have learned that an alternative name for this process is the Systems Development Life Cycle.
This concept is based on the potential combination of software and hardware configurations. Now, it isn't always as such; a system can also be comprised of only software or of only hardware. Defined into a six stages: "requirement analysis, design, development and testing, implementation, documentation, and evaluation". I would take it a bit further and say there are actually seven stages due to the potential 'clutter' of too many important stages that I consider valid enough to give each one it's own stage to check off the list, but this is my own opinion. Although the stages remain the same and can still be composed of six, I will have each step listed separately for ease of navigation.

Phases

Below I plan to display each of the phases: Planning, Requirement Analysis, Design, Development, Testing, Implementation(Deployment), and of course, Maintenance. I will also state the current stage that DevSecOps would be involved in the development process.

Planning

The first stage of the life cycle is the identification of difficulties that the software to be created will resolve. This also includes creating a 'check-list' of tasks you plan to complete to reach goals and the ways it will meet the customer's or stakeholder's demands.

DeVSecOps: Identification of potential security requirements and review of potential threats and vulnerabilities.

Requirement Analysis

The second step of the starting process is to take in the analysis from the client and begin designing the features of the solutions for the problems they presented during the planning process.

Design

The design phase is when you begin to structure the technical details of the product. Taking the information gathered during the requirement analysis and reconstruct them into a structured design document, focusing heavily on the technical aspects. This includes prototypes, user interfaces, sketches, screen designs, etc.

DeVSecOps: The application of security design principles and the creation of a structured design document including threat modeling, risk analysis, access control, and encryption

Development

The development phase is when you take all that you have been brainstorming and documenting and translating it into system components. This is critical for the preparation of integration and testing individual elements for usability.

DeVSecOps: The use and integration of tools like firewalls, security settings, and access controls and procedures for testing to prevent regressions and maintain quality with each release.

Testing

The testing phase begins after the software has been built and deployed to a testing environment. This is when developers evaluate all defects and bugs within the software and confirms that it meets quality standards with functional testing, unit-testing, scalability and speed under different conditions, security testing for vulnerabilities, usability testing, and acceptance testing.

-DeVSecOps:
Conducting code reviews for compliance with security standards.
Running security tests like penetration testing, static
application security testing, and interactive application
security testing.

Implementation/Deployment

Considered as the final stage of the software development life cycle. The final stage where all checks have passed and the final product is delivered to the client in a live production environment.

DeVSecOps: Addressing any security concerns that may impact the live production system. Focusing on logging change activities and potential configuration variations between the production environment and deployment settings.

Maintenance

Now, I know I said the deployment was the final stage and that still remains to be true, but, like most things, maintenance is an ongoing, continuous thing when prolonging quality products. This commitment to quality, and performance, requires levels of upkeep such as updating software with new features, as demands change over time, rectifying bugs and issues.

DeVSecOps: Continuously monitoring products for threats and vulnerabilities and maintaining up-to-date software with security patches.

In conclusion each stage plays a critical role when producing quality software for clients or really for anyone that may require it. During my adventure into software engineering I find how fascinating each and every topic can be and how important each category relates to what I, and others, do every day. In the future I plan to cover the Software Development Life Cycle Models and how they relate to everything I covered.

Intro to the Terminal

Cody Daigle — Mon, 15 Apr 2024 03:41:46 +0000

Historically, a terminal was this physical device that consisted of a tad more than a keyboard and monitor and used to input and transcribe from, data in a computing system. But, now the concept has been absorbed into software. Ultimately, a terminal is a serial computer interface, to an implied operating system, that accepts text inputs to issue commands to a desired Command-line interpreter or shell.

What’s the shell?
A shell is a computer program, living in the outermost layer of a computers operating system, that spills the beans on operating system's service for a user or a program. This is achieved either through a command-line interpreter(CLI) or Graphical User Interface(GUI), depending on the operation. There are various Unix System shells such as Bash, zsh, Ksh, tcsh, etc.

Bash Shell

A POSIX-compliant, command processor, that generally runs in a text window, or console that accepts commands to perform actions. Bash is usually the default for most Unix & Linux distributions and like many other Unix shells, Bash supports command substitution, iteration, filename globbing, etc.

"written by Brian Fox for the GNU Project as a free software replacement for the Bourne shell. The shell's name is an acronym for "Bourne-Again SHell", a pun on the name of the Bourne shell that it replaces and the notion of being "born again".

Z Shell

Similar to Bash, Z Shell(zsh) is an extended Bourne shell containing improvements and combined features from the Korn Shell(ksh) and tcsh(Tenex-csh). The healthy combination brings the functionality of updated variable array handling, extended globbing, command-line completion, and customizable prompts. After the release of macOS Catalina, zsh was adopted as the default login shell.

Options

Additional items can be installed through the terminal to further improve performance like VIM and NPM.

VIM is an open-source text editor reincarnated from the original Vi editor that supports both graphical and text interfaces on any platform. Though it is challenging to master and is known to give the worst first impression, it provides commands for complex text-related tasks, and it is highly customizable and scalable. Luckily VIM has 'games' that you can utilize to improve proficiency such as VIM-Adventures or even simply running $ vimtutor in your shell prompt.

Node Package Manager is undoubtedly the largest software library and maintains it's place as the default for JavaScript. Containing it's own Command line client to download and install any of the 800,000 code packages or any software shared by developers. With that being said, Node.js is required to install NPM, but another tool that is available called Node Version Manager. Node Version Manager, or NVM, allows developers to switch between multiple versions of Node.js on one machine. Though Node.js can be used on both front-end and back-end, Bower can be installed through NPM which is a package manager optimized for front-end development. Now, NPM may be the largest and most used package manager today, but there are other options available. Such as Yarn, which is an updated, faster NPM. And PNPM, a newer NPM with a different package resolution algorithm for more speed and efficiency. Obviously the best choice depends on personal preferences and needs

Terminal Shortcuts
Here is a short list of just a few of the shortcuts and commands for your terminal:

Manual Commands

Up Arrow // Shows previous command
Down Arrow // Shows next command
Tab // auto-complete current command
Ctrl + R  // Terminal search command
Ctrl + C  // Cancels Commands
Ctrl + L  // Clears the terminal
Ctrl + D  // Exits the terminal
Ctrl + Shift + ` // Open/create new terminal
Ctrl + a  // Navigates to beginning of command line
Ctrl + e  // Navigated to the end of command line
Ctrl + t  // Swap the last two characters before curser
Alt + t   // change positions of current word with previous

File Navigation

man   // shows the manual of Linux/Mac commands
ls    // List all files/directories under a designated directory
pwd   // Prints the working directory
whoami // Shows the current logged in user
ls -a  // List files including hidden ones
cd <directoryName> // Change directory
cd~    // Change to home directory
cd ..  // Revert to parent directory

Modifying

touch <fileName>  // Create a file
rm <fileName>     // Remove the file
cp <filename><directoryName> // Copy file
mv <filename><directoryName> // Move file
mkdir    // Create a directory
rm -r <directoryName> // Remove directory
rm -rf <directoryName> // Remove directory & contents
mv <directoryName><directoryName> // Move directory

In conclusion, there are endless resources on Terminal commands and options available to every shell that provides developers with built-in tools to allow convenience and efficiency. I will end with some 'cheat-sheets' that I have collected and I hope they help you as much as they have helped me.

Terminal Key Combinations
VS Code Keyboard Commands
GitHub Cheat Sheet

The Heroku Platform

Cody Daigle — Mon, 08 Apr 2024 06:31:38 +0000

One of the first cloud, Platform as a service (PaaS), products that has been in development since 2007 and originally ONLY supported the Ruby language with the intent for supporting projects compatible with the Rack web server interface. The Heroku we know today actually supports several different languages in addition to Ruby. With that being said Heroku is within the realm of being classified
as a Polyglot Platform due to developers having access to features for building, scaling, and running applications similarly across the majority of those languages.

Current supported languages:

Node.js
Python
Java
PHP
Go,
Scala
Clojure.

Architecture:

"Applications that are run on Heroku typically have a unique domain used to route HTTP requests to the correct
application container or dynos. Each of the dynos are spread across a "dyno grid" which consists of several servers. Heroku's Git server handles application repository pushes from permitted users. All Heroku services are hosted on Amazon's EC2 cloud-computing platform."

Runtime

Applications on Heroku run inside virtual, lightweight, Linux containers, called Dynos, also referred to as smart containers, on a fully managed, dependable runtime environment that ensures configuration,
load balancing, security and everything in between that is essential for production. Code can be written using any of the
supported languages to a build system that produces an execution ready application that would not require manual intervention due to the constant upkeep of their language stacks. Dyno types vary depending on application sizes from small scale to high traffic services.

Data Services and Ecosystem

Developers have access to the Heroku Elements Marketplace, that offers the ability to add necessary technologies and technical solutions specifically to support any and all stages of application development and operations that can be integrated with ease. Additionally, developers have access to 200+ fully managed cloud service add-ons allowing the ability to extend application functionality and streamlined control, Buttons, and Buildpacks for stack customization that can be installed and managed, along with pre-integrated services like MongoDB, ClearDB MySQL, etc, on their CLI and/or Dashboard.

Fully managed data service add-ons:

Heroku Postgres(SQL)
Heroku Redis
Apache Kafka on Heroku

Developer and Operational Experience

Heroku defines the Developer Experience(DX) as "an app-centric approach to software delivery so developers can focus on
creating and continuously delivering applications, without being distracted by servers or infrastructure." Furthermore,
developers can directly deploy from common tools such as GitHub, or other CI systems, and Git. As for the Operational Experience(OpEx), developers can rest a little easier when working to identify issues, remedy them, and troubleshooting with the assistance that is provided to them when addressing application health. Tools are provided to notify you in the case something goes awry. Also, scaling, both vertically and horizontally instantly, can be applied automatically to your smart containers if the response time for requests exceed a specified threshold. Lastly, the Operational Experience wouldn't be complete without access to the built-in monitoring of all vital deployment information
through Application Metrics. Above all, these features don't come at any additional cost for access.

The age old question

Is it safe? I can comfortably assume that everyone worries about the safety of their data and Heroku takes great pride in
their endeavor to protect the sensitive data entrusted to them. Just to start, Heroku maintains ISO,
SOC, HIPPA, and PCI compliance. On top of that,they perform regular audits to continuously
solidify the trust their customers have in them.

Additional Heroku Products

Heroku Connect
Created Heroku Applications can easily integrate within Salesforce deployments ad scale due to seamless data synchronization between Salesforce organizations and Heroku PostGres Databases.

Heroku Teams
Team management tool for collaboration and ease of control for bringing developers, tools, and processes together for efficient software development inside a team like environment

Heroku Redis
Fully managed service provided by Heroku to help manage CLI instances, giving customers performance visibility, and associate PostGres Data using SQL tools to fain business insights

Heroku Enterprise
Helping large companies improve collaboration within the different teams through provided services and features. Some of
these features include identity federation, access controls, and private spaces for managing development processes, users,
and resources.

Heroku Plans

I hope this brief rundown of what deploying on Heroku can offer you as a developer. Although they did do away with their free packages in 2022, Id say with the wide range of provided tools even at the lowest tier Heroku is definitely a deployment service to consider when looking around.

A Little About Linux

Cody Daigle — Sun, 25 Feb 2024 16:36:21 +0000

Linux is a Unix-like, monolith and modular, open source, multitasking kernel released in 1991 by Linus Torvalds and not much later it was adopted as the kernel for the GNU operating system. Since then Linux has contributed to a vast number of operating system distributions. A solid amount of these distributions use Linux in their name, but to emphasize the importance of GNU Software, the Free Software Foundation insists on the use of the name GNU/Linux. GNU Software was written to be a Libre Software (free software), replacement for Unix, thus causing a bit of controversy.

Open source follows these key tenets:

The freedom to run the program, for any purpose.
The freedom to study how the program works, and change it to make it do what you wish.
The freedom to redistribute copies so you can help your neighbor.
The freedom to distribute copies of your modified versions to others.

Programming

Either directly, or through third-party ports, a majority of programming languages provide support for Linux in some way. I mean, the intention behind Linux-based distributions is for developers for interoperability across different operating systems. Additionally, Linux contains a broad treasure chest of programming tools necessary in Linux development for building operating system programs and/or applications. These tools can be located inside the GNU ToolChain, luckily this also entails other useful items such as the GNU Build System and the GNU Compiler System. Linux, like other Unix-like systems that include traditional specific-purpose programming languages targeted at scripting, also includes general management, text processing, and system configuration capabilities. Multiple programming languages, such as Python, GO, Rust, Ruby, Perl, and Java contain a cross-platform reference Implementation that supports Linux. Majority distributions can include support for many dynamic languages and CLI Languages, while also allowing languages that target the GNU system utilities, like Guile Scheme, an extension language that can make static, compiled programs of Unix Design quickly and efficiently through a high-level, functional scripting system.

System
Linux Systems are used anywhere from embedded systems, the top 500 supercomputers in the world, which is nearly all of them, and even solidified a place among server installations.
Linux popularity and success has even outreached to various national governments around the world. For example places like China ONLY uses Linux, Spain for education, France, North Korea, Germany, even the Russian government developed their own Linux distribution named G.H.ost Project. Taking a step from desktops for a second, arguably Linux's greatest success, in the consumer market, has to be with mobile devices. Smartphones and tablets are dominantly Android, consisting of a modified version of Linux Kernel, not to mention the accessories that pairs with them like smartwatches, for example. Later in this article I will mention Microsoft's previous hold on the desktop operation system market, but when comparing video game availability for Linux versus Microsoft you can see that Microsoft holds that title. That may not be your thing, but it's interesting to note how large of a gap there is. If it so happens to be an interest of yours then it wouldn't hurt to mention that Valve, the developer of a software distribution platform (Steam) and famously known for their game Half-Life, has adopted Linux create their own gaming-oriented operating system, SteamOS, that has been implemented into their Stream Deck platform. Neat.

Kernel?
A kernel is a computer program at the heart of an operating system. Generally this has absolute control over everything in the system. Including mitigating and preventing conflicts
between processes, facilitating interactions between both the hardware and the software components. The best way to sum up each of their roles is: A computer's central component of
it's system is responsible for executing programs, whereas the kernel's responsibility lies with deciding which of the current running programs should ne allocated to the processor
(s). The most important parts of this is code is loaded into a safe location in the operating system address space called the 'kernel Space'. This is to protect itself by denying
application software and other less vital parts access, so it can safely handle hardware devices, manage interrupts, and run processes. On the other side of the address space lies the
'user space', a separate part of memory for browsers, video and music players, and other application programs. These kernels can have different architectural designs like monolithic,
operating only in a single address space. And modular, which runs majority of it's process in the user's space. The Linux Kernel is monolithic, but with a modular design, meaning it
has the capability to extend influence beyond it's Kernel space at runtime, through the use of inserting and removing loadable kernel modules(LKM) to aid with adding system calls,
support for new hardware, and file systems.

~~Designed~~Evolved!
At AT&T's Bell Labs, in 1969 Unix Operating system was brought to life and then later released in 1971, though it was written entirely symbolic machine code, alternatively assembly language. Between 1972 & 1973 it was rewritten in the 'C' programming language by AT&T's very own Dennis Ritchie. Due to the growth of Unix and becoming a proprietary product, the GNU Project was founded, with the goal of developing a 'Complete Unix-compatible software system' made solely from free software. Then, MINIX, a minimal Unix-like operating system (Mini-Unix) was created in 1987 with a specific purpose: To teach students and those wanting to learn the principles of operation systems. Three years later Linus Torvalds decides to enroll in a college course and obtained the textbook Operating Systems: Design and Implementation by Andrew S. Tenenbaum, the created of MINIX. This exposure to Unix is what sparked curiosity in Torvalds and he began working on his operating system kernel, later becoming Linux Kernel.

Honest I didn't want to ever release it under the name
Linux because it was too egotistical. What was the name I reserved
for any eventual release? Freax. (Get it? Freaks with the
requisite -X.) In fact, some of the early make files --the files that describe
how to compile the sources-- included the word "Freax" for about
half a year. But it really didn't matter. At that point I didn't need a
name for it because I wasn't releasing it to anybody.
And Ari Lemke, who insured that it made its way to the ftp
site, hated the name Freax. He preferred the other working name I
admit that I didn't put up much of a fight. But it was his doing. So
I can honestly say I wasn't egotistical, or half-honestly say I wasn't
egotistical. But I thought okay, that's a good name, and I can
always blame somebody else for it, which I'm doing now.

Linus Torvalds p84 and p88 "Just for fun"

Business is Booming!
Rather than Linux based production environments being solely used by hobbyists, it soon became popular in the supercomputing community. Even organizations, like NASA, made the financial decision to replace their current machines with computer clusters made of commodity computers operating on Linux. I briefly mentioned that there was a point when a monopoly was on the Desktop Operating System Market and in an attempt to break free of Microsoft's reign, Linux support was offered by other technology companies, like Dell and IBM.

Market
There has been numerous studies on free/open-source software focusing on subjects like reliability as well as market share. Linux is no exception and a large amount of the studies have been specifically on Linux and it's ever-growing market. In fact, it's expected that the growth of the Linux operating system market size will see an increase of over 19% by 2027. Compared to 2019, which had them set at $3.89 billion, this has them expected to reach $15.64 billion. These predictions are attributed by Linux's relative success due low cost, security, reliability, and freedom from proprietary lock-in.

Final Thoughts
Although I will always own a PC it's hard ignore the advantages to learning and creativity that Linux Systems can provide. Now, I want you to take a second and think about your opinion on Linux. Now your opinion on Windows. Got it? Ok. Here is a situation: You need a server for your project. How many team members do you plan to have?

Cost of Windows Server 2016: Standard Edition:

Windows Server 2016: Standard Edition - $882.
Client Access License: $38.00 (per person)

Cost of a Linux Server

Linux Server: $0
Client Access License: _$0

If you want to see the actual scenario with more detains

The Wonders of Node.js

Cody Daigle — Mon, 19 Feb 2024 02:37:43 +0000

Node.js is a single thread, open source, cross-platform runtime environment, JavaScript interpreter that is or will be a vital tool to help anyone from an expert to beginner. In this article I will lay down some of it's foundational traits and capabilities to help you grow and understand the functionality that it possesses.

A Little History

Prior to the creation and implementation of Node.js, servers would struggle with high volume concurrent connections. Due to this issue code would either need the use of multiple stacks or imply blocking on entire processes. As you could imagine this could have a serious impact on businesses and their ability to meet a high volume of users requirements when engaging with their products. In 2009 Ryan Dahl created Node.js for that purpose. Although it was originally for Linux and Mac users it was later developed to be utilized on Windows as well.

What is Node.js?

Scripture defines Node.js as: An open-source, cross-platform runtime environment that allows developers to create all kinds of server-side tools and applications in JavaScript. The runtime is intended for use outside of a browser context (i.e. running directly on a computer or server OS). What makes Node so performant is it allows the developer to run the V8 JavaScript engine, which is the core of Chrome, outside of the browser. That may not seem exciting right now, but this is just the tip of the iceberg!
Some other JS engines would be:

Firefox has SpiderMonkey
Safari has JavaScriptCore (AKA Nitro)

Node.js comes equipped with a standard library, including a set of asynchronous input/output primitives, that prevents the blocking operation for JavaScript. Generally, Node.js libraries are created using non-blocking paradigms so any blocking is considered an exception.

Asynchronous vs Synchronous
Just as I mentioned before, Node is an Asynchronous I/O and it allows the utilization of a handling input/Output operations that does not perform blocking on processes. Essentially this action performs an action on data, or a resource, and returns expedited without the need to wait for a response from elsewhere. It's primarily used when a developer wants to perform an action, but doesn't require immediate interaction with the application or resource they are involved with. The multitasker or dedicated user's tool that allows you to work on multiple threads at once without being hung up. However, there are some restrictions that come with asynchronous I/O if being used for a network communication. For example if any other part of an application being worked on is dependent on having 'reads' or 'writes' then they must be completed before those can take place or else it can cause issues later along the line when running load conditions.
Now, a synchronous I/O it the opposite. It's a technique in which processes are blocked until the operation is completed. I like how GeeksForGeeks describe it:

This can happen when there is no way for processes to continue until their scheduled event has finished. In this case, synchronous I/O needs to wait patiently till it has been given permission by its supervisor program to proceed with further processing.

I did mention that Node.js has some blocking behaviors in it's arsenal. For example if JavaScript is exhibiting poor performance from something like being CPU intensive, instead of waiting on an operation, like I/O, it's generally referred to as blocking. This synchronous method is the standard library uses Libuv.

Why use it?

So we've talked about what Node is, but why use it?
Aside from the layout that makes up Node.js it has a magnitude of uses. When talking about it's functionality with blocking it opens the door to handle thousands of concurrent connections with just a single server and the thought of managing thread concurrency. Ultimately avoiding a potentially large source of bugs.
Furthermore, Node brings a unique advantage to front end developers that write JavaScript for the browser. Instead of learning an entirely new language this advantage allows them to write server-side as well as client-side code. With those same developers in mind Node.js has the capability to switch between it's ECMAScript versions so they won't have to rely on the users to update their browser in order for them to perform actions on it.
Node.js recommends these before going in headfirst:

Lexical Structure
Expressions
Data Types
Classes
Variables
Functions
this operator
Arrow Functions
Loops
Scopes
Arrays
Template Literals
Strict Mode
ECMAScript 2015 (ES6) and beyond

//Example of server-side Node syntax
const http = require('http');

const host = '127.0.0.1';
const port = 2000;

const server = http.createServer((request, response) => {
reponse.statusCode = 200;
response.setHeader('Content-Type', 'text/plain');
response.end('this is an example of Node.js on a local computer.');
});

const listener = `Node.js server running on http://${host}:${port}/.`
server.listen(port, host. () => {
console.log(listener);
});

I hope you found this information useful and has you ready to work with Node.js. Aside from it's capabilities and functionality there are other assets that are involved and will ultimately help you in the ways you need.

Encryption Methods: Protecting Data

Cody Daigle — Mon, 05 Feb 2024 13:19:47 +0000

Have you ever been concerned about whether your information or online actions are safe? In this article I will explain the multiple ways encryption is utilized today, it's importance, and hopefully provide the everyday user some ease when accessing their information.

Encryption's Purpose:

The primary goal behind encryption is to protect important, personal information, and data from unauthorized personnel. The world today allows anyone to access so much information just from their fingertips. Anywhere from learning how to do something new, job related tasks, or even checking bank statements. Keeping vital information private is paramount and luckily there are many ways this can be achieved.

How Is Something Encrypted?

The act of encryption takes plaintext, human-readable data, and alters it to appear as randomized, incomprehensible strings of text with alphanumeric characters. With that transformation the data that could be read is now known as ciphertext and is otherwise useless to those that it does not pertain to. How would it become understandable again when it's accessed by the authorized user? This is accomplished with the tool called a cryptographic key that uses a string of randomized, mathematical values that allow authorized personnel to decrypt that data. Cloudflare defines a cryptographic key as:

A string of characters used within an encryption algorithm for altering data so that it appears random. Like a physical key, it locks (encrypts) data so that only someone with the right key can unlock (decrypt) it.'

Types Of Encryption:

Due to all the different types of data and importance for applying such a security to information many different methods of encryption exists today. These methods are roughly categorized into two groups: Symmetric Data Encryptions and Asymmetric Data Encryption.

Symmetric data encryption, also known as 'Private Key
Cryptography', utilizes a key to encrypt plaintext and decrypt ciphertext. The access to this key is only accessed by the authorized recipients that are sending and/or receiving data. This process is the fastest of the two due to only requiring a single key and is most useful when dealing with larger quantities of data.

Examples of symmetric encryption algorithms would be:

Advanced Encryption Standard (AES)
Triple Data Encryption 3DES/TDES

Asymmetric data encryption, also known as 'Public Key Cryptography', utilizes two separate keys, a public key and a private key. Splunk explains: "The public key, as the name suggests, is either publicly available or shared with authorized recipients. The corresponding private key is required to access data encrypted by the public key. The same public key will not work to decrypt the data in this technique".

Although this method is relatively slower in action it is the most secure form today when it comes to protecting personally identifiable information. Some examples of asymmetric encryption algorithms are:

Rivest-Shamir-Aldeman (RSA)
Diffie-Hellman (DH)
Elliptic Curve Cryptography (ECC)

Applications:

Now that we have discussed symmetric and asymmetric data encryption let's look at how these would be applied to data. Primarily there are three ways that encryption is applied: At rest, In Transit, and End-to-End. Data that is encrypted and stored and not being accessed or moving through a network is referred to as data at rest, like a flash drive or database. What about data that is being sent? Data in transit is when data is encrypted and then transferred between nodes in a network. With that being said it doesn't have to be encrypted before this takes place, but will be as it travels and then decrypted when it reaches it's destination. Imagine how emails are sent to specific users: When you write an email you are creating data that is stored and when sent it becomes encrypted and decrypted when it arrives at the authorized location. Finally, we have End-to-End_ which utilizes both applications of data at rest and data in transit. When data is created it becomes encrypted and stored and when transferring said data between network nodes only the encrypted data is sent and decrypted, from ciphertext to plaintext, at the specified location.

General Use:

The methods I described above are used in everyone's lives in some way or another, but what about general internet use? When using the internet you are utilizing an application later protocol called Hypertext transfer protocol, or HTTP, inside the internet suite model that encodes information and moves it between a server and a client/browser. Notice I didn't mention anything about it being encrypted? That is where the 'S' in HTTPS comes in. The only difference, besides the letter, is it's 'Secure', meaning HTTPS uses Secured Socket Layer certificates to establish, and digitally sign, an encrypted connection on an HTTP request/response. This is considered as a TLS handshake, allowing a secured session to protect data.

What could go wrong?

We know encryption of personal data is an amazing asset that is used to protect confidential information like messages, files, phone calls, etc, but what if encryption was used in a destructive way? What if I told you there was a type of cryptovirological malware that can permanently block user access to personal information by encrypting it? Ransomware attacks utilizes swift encryption methods that infects and encrypts data and generally wont be released unless a condition is met. Ryan Kovar, SURGe. says "The Median Ransomware variant can encrypt nearly 100,000 files totaling 53.93GB in forty-two minutes and fifty-two seconds. A successful ransomware infection can leave organizations without access to critical IP, employee information and customer data.”

These attacks are often seen in phishing emails that have attachments in them with the intent to perform harmful actions on the victim.

In conclusion data encryption is vital today in order to keep important information safe and luckily we have many resources to help do so. Whether you are an everyday user or work directly with confidential information it is reassuring to know the resources we have at our disposal and they are improving every day.

'this' and Invocation Patterns

Cody Daigle — Fri, 15 Dec 2023 20:22:22 +0000

A love story.

What is the 'this' keyword and these Invocation Patterns!?
Well, 'this' is a reserved keyword within JavaScript that refers to an object. Now, in order to determine which object it's referring to is solely based off of how the function, it resides in, is called/invoked. Luckily, there are different invocation patterns that help you zero in on how 'this' can be utilized so the value can be determined and used as intended. These patterns are: Global Reference, Free, Method, Constructor, and Call/Apply/Bind.

Global Reference / Scope Invocation: When 'this' is invoked by itself or in the global scope then it will refer to the Global Object Window.

console.log(this)

Free Function Invocation: When a function is invoked traditionally, 'this' also refers to the Global Window Object like Global Invocation, above.

function freeFunctionInvocation() {
  return this; // <- Refers to the Global
}
freeFunctionInvocation();

Method Invocation: When a specific object is to be referenced then the function can be defined as an object method. Due to the dot notation connecting the function to the object it creates an ownership over the function.

const obj = {
  firstName: 'Paul',
  signature: function () {
    return `McBeth, ${this.firstName}`
  }
}
obj.signature(); // <- McBeth, Paul

In obj.signature() 'this' directly references what is to the left of the '.' at the time it is called therefore the signature function is called as a method of the 'obj' object.

Constructor Function Invocation: What is a constructor function?

Rollbar defines a constuctor as: 'A special function that creates and initializes an object instance of a class'.

Simply it's a template object, beginning with a capital letter, used to create empty objects with the constructor's properties. When an object is created with a constructor it is done using the 'new' keyword.

function Person(name) {
  this.name = name; //'this' refers to the Person constructor
};

let person1 = new Person(); 
person1.name = 'Simon'; //assigns the name property to 'Simon' in the new object.

By declaring person1 and assigning it to the constructor with 'new' will allow for a separate copy of that object.

Call() & Apply(): Call and Apply are methods that implicitly bind 'this' to the first parameter. When using these methods you can specify what you want 'this' to refer to by placing it as the first parameter and then with the arguments separated by commas, when using .call(), or an array, when using .apply().

var pdga = {
  founderFirstName: 'Ed',
  founderLastName: 'Headrick',
  founderFullName: function () {
    var fullname = `${this.founderFirstName} ${this.founderLastName}`;
    return fullname;
  }
};
var hq = function (sport, location) {
  console.log(`${this.founderFullName()}'s ${sport} Headquarters is in ${location}`);
};
//call method arguments are separated by commas
  hq.call(pdga, 'Disc Golf', 'Appling, GA');
//apply method arguments are separated by an array
  hq.apply(pdga, ['Disc Golf', 'Appling, GA']);

The bind method: MDN defines Bind() as: 'creates a new function with the same body, but the value of 'this' is permanently bound to the first argument, regardless of how the function is being called' So, unlike call and apply, 'this' will always be the first argument when utilizing bind. With that being said, bind will create a new function that wasn't in the original object, but it can adopt the properties, as well as the methods.

var pdga = {
  founderFirstName: 'Ed',
  founderLastName: 'Headrick',
  founderFullName: function () {
    var fullname = `${this.founderFirstName} ${this.founderLastName}`;
    return fullname;
  }
};
var hq = function () {
  console.log(`${this.founderFullName()} founded the Professional Disc Golf Association`);


}
var steady = hq.bind(pdga); // <- Creates a copy of the 'hq' function and binds pdga to 'this'
steady();

In conclusion, when utilized correctly, or at least as intended, it can change the dynamic of how you create your work, moving forward! Finally understanding something so complex has that effect! At least for me, it does. Even if you don't use every method, it's good practice to understand how to decipher what each invocation is telling you.