DEV Community: DavidNNussbaum

React Or Angular – Which Is Better? It Depends.

DavidNNussbaum — Sun, 06 Feb 2022 00:37:35 +0000

React which was developed by Facebook is a JavaScript library that facilitates the creation of interactive user interfaces. It uses server-side rendering to provide a flexible, performance-oriented solution and is unidirectional. Angular was developed by Google and is a structural framework (as opposed to just being a library) for developing dynamic web apps. It is bidirectional.

Many postings extoll the virtues of one system over another, yet as with most things in life one must evaluate the situation with a view of what the particular circumstances are. In the final analysis, one should not simply add the number of factors that favor React or Angular but also take into account the importance of each factor to you.

If you don’t have time for a learning curve – React is better.
If community support is important – Angular is better.
If installation time cannot be lengthy – Angular is better.
If flexibility is important – React is better.
If you want simple updates – React is better.
If you want to develop Native, hybrid, or web apps – React is better.
If you want to develop Single Page Applications or mobile apps – Angular is better.
If you want to develop native-rendered apps for Android and iOS devices – React is better.
If you want to develop feature-rich, large-scale applications – Angular is better.
If you don’t want to have to update the model state with every data change -Angular is better.
If you want a single tool for testing and debugging – Angular is better.
If you want faster documentation – React is better.
If you prefer JavaScript – React is better.
If you prefer TypeScript – Angular is better.
If third party integration is important – React is better.
If ease of moving from one view to another is important – Angular is better.
If enhanced support for server side rendering is important – React is better.

Thank you for reading!

A Review Of Several Python Supervised Learning Classifiers With Some Of Their Advantages And Drawbacks

DavidNNussbaum — Mon, 31 Jan 2022 01:23:05 +0000

In the realm of Python supervised learning there are many classifiers that can be accessed utilizing the scikit-learn library. These are algorithms that are given training data which consists of a large portion of the data on hand. A certain percentage, many times around 20%, is saved as the test set. The information that we want the model to determine is designated as the target. The model uses the features associated with each unit of the training set to determine the relationships between the features and the target. The model is then given the data from the test set which has the target removed and a determination is made as to how accurate the model is in predicting the target in the test set.

We will review various classifiers with their pros and cons.

K-Nearest Neighbors – The model studies which pieces of data are closest to each other. It is a simple approach but slows down as the data set becomes larger.

Logistic Regression – This model is good for determining an outcome. There are three types:
1) Binary Logistic Regression – The model predicts whether something is or is not true – if an email is spam or not or if a tumor is malignant or not.
2) Multinomial Logistic Regression – There are three or more categories without ordering. An example would be to determine which is the favorite activity, horseback riding, bowling, or swimming.
3) Ordinal Logistic Regression – There are three or more items with ordering for example rating of baseball teams from 1-10.

There is a decision boundary and the determination is made based on where the item appears relative to the decision boundary.

A drawback would be that it is not used to classify items, for example to determine if a picture is of a horse, a cow, or a chicken.

Decision Tree – In this algorithm the goal is to create a model that predicts the value of a target variable in the test data by learning simple decision rules inferred from the training data features. The logic is transparent and can therefore be followed.

Two of the downsides are that a person can create over-complex trees that do not generalize the data well. In addition, one can create biased trees if some classes dominate.

Random Forest – Here many decision trees are used, each working on a subset of the data. Their results are averaged in an attempt to obtain a more accurate result.

Drawbacks include that the actual functioning is not transparent and for a large data set there is tremendous usage of memory.

Support Vector Machine – This model segregates the given dataset in the best possible way. The distance between the nearest points is known as the margin which is better if it is smaller. The objective is to select a hyperplane with the maximum possible margin between support vectors in the given dataset. Support vectors are the data points, which are closest to the hyperplane and will define the separating line better by calculating margins. The hyperplane is a decision plane which separates between a set of objects having different class memberships.

A drawback would be that it is not suitable for large datasets.

Voting – This model basically accumulates the results of multiple other models and makes a prediction based on one of two types:
1) Hard voting – The votes of the various models are summed and the class with the most votes is predicted.
2) Soft voting – The predicted probabilities from the various models are summed and the prediction is made based on the class label with the largest sum probability.

A drawback is that multiple models have to be run.

Naïve Bayes – This algorithm goes on the assumption that the various features are not dependent one on another. It is used for classification and goes by probability. The class with the highest probability is considered to be the class to which the data point belongs. It is considered a fast algorithm.

A drawback is that this algorithm presumes that all features are independent of each other which they rarely are, however despite this for binary classification there is a relatively high successful prediction rate.

Thank you for reading!

Creating A Hash Table

DavidNNussbaum — Tue, 04 Jan 2022 20:01:05 +0000

JavaScript includes Hash Tables which are a data structure that allow one to create a list of paired values. One is then able to retrieve a certain value by accessing the key for that value, which was previously placed into the table. Andrei Neagoie covered this in his Udemy course entitled “Master the Coding Interview: Data Structures + Algorithms.’

First a class named “HashTable” is created with a constructor having a parameter of the size with the data consisting of a new array with the same size as a parameter.

A private method (which theoretically should not be reachable outside of its class) called “_hash” is created with a parameter of the key. The hash is initiated with a value of 0. An iterating variable of “i” is created which is not allowed to exceed the length of the key. A variable called “hash” is then created containing The “charCodeAt()” method which returns the Unicode of the character at a specified index in a string. The data length is then invoked and the hash returned.

We next need a method to add keys and values to the Hash Table. A method called “set” is created with its parameters being the key and value. A variable “address” is created which equals the “_hash” method. If there is no current address then an empty array is instituted. If there is a current address then the new key/value pair is added.

The next step is to create a method which would allow one to retrieve information. One would do this by entering the key and then one could display either the key, the value, or both. A method called “get” is created. In this method the variable “address” again equals the “_hash” method. A variable currentBucket is created equaling the address. As long as currentBucket exists, it is iterated over until the key equaling the desired key is located and in this case the value is returned (the key being at index 0 and the value at index 1). If the currentBucket does not exist then undefined is returned.

Finally a method called “keys” is created that will produce an array of all the keys. It has no parameters. A variable called “keysArray” is created which is an empty array. The data is the iterated over with the keys being pushed one by one into the empty array and the array containing the keys is returned.

The usage of this function entails using a variable to create a new instance of the class “HashTable” with the size as the argument.The methods within the function are then appended to the variable to obtain the desired results. For the “set” method the key and value are the arguments and for the “get” method the key is the argument. The “keys” method has no arguments but don’t forget the (). An example is given below:

Thank you for reading.

Prepending, Inserting, and Deleting Nodes In A JavaScript Singly Linked List

DavidNNussbaum — Mon, 27 Dec 2021 17:51:32 +0000

To view the code previously written you can look at the previous posting entitled “Building a Singly Linked List in JavaScript”. A modification is being made to the original code. Since new nodes will be added multiple times (as opposed to initially when it was only done once) we are first creating a new class called “Node” with a value and initially pointing to null. This is done so that the coding does not have to be repeated and only a new instance of this class needs to be created.

In the prepend method, first a new instance of node is created with the value being supplied as the parameter. The previous head of the Linked List now becomes the node pointed to by the new node and the new node then becomes the head of the Linked List. The length is increased by one and the Linked List is returned.

The methods to insert a new node in a certain spot and to delete a node at a particular spot both require finding that spot and both methods share this code. A separate method is therefore created to carry out this operation. The method is called here “proceedToIndex” and has as a parameter the index that we are looking for. A variable called “counter” is created with an initial value of 0. Utilizing a while loop, the node being iterated on is constantly moved forward and the counter is increased until the counter equals the index that was entered as an argument and then returns the node located at that index.

The method to insert the new node can now be created. We first use an "if loop" to ensure that if the index number given is equal to or higher than the actual number of nodes then the append method is activated to add the value as a new tail for the Linked List. If the index argument is smaller than the number of nodes then the remainder of the insert method is activated. First a new instance of Node is instantiated. Next a variable “first” is created which utilizes the “proceedToIndex” method to locate the node which is at the point of insertion. The parameter is index-1 because the Linked Link index starts at 0 and therefore a submitted number of “4” would be at index”3” in the Linked List. The variable “holdingPointer” is what the previously identified node points to. What it points to is updated as the new node which then points to the node that was previously immediately after the node before the new node. The length of the Linked List is the increased by one. In summary, if the new node “N” is being inserted after index 5 containing node “P” that was originally followed at index 6 with node “F”, the pointer in node “P” (index 5) is changed from “F” and now points to “N” (which now at index 6) and the pointer of “N” now points to “F” (which is now at index 7).

The method to delete a node is simpler. First, we proceed to the appropriate index utilizing the “proceedToIndex” method. The variable “deleteableNode” representing the node to be deleted is established as the node after the previously identified one. The pointer of the node previous to the node to be deleted is now changed to point to the node after the node to be deleted, thus eliminating the node between the two from the Linked List. The length of the Linked List is then decreased by one.

As a simplification, a method is being created so that the linked list appears as an array in the terminal. First an empty array is created. The current node is started as the head and then each next node becomes the current node in turn and is pushed into the array until the last node is passed which means that the current node is now null. The loop ends at that point.

Thank you for reading!

Using JavaScript To Compare Two Strings Containing Deleting Element(s) – Two Versions

DavidNNussbaum — Thu, 23 Dec 2021 17:21:27 +0000

There are always several ways to code a solution and an example of this will be shown here. One is presented with two strings to be compared and the program should yield “true” if they match and “false” if they don’t. These strings can contain one or more of the symbol “$”. Each “$” deletes in turn its preceding letter. The comparison of the strings should take this into consideration.

In order to take Big O time consideration into account, “const” (the faster option) is used instead of “let”. Since the loops are not nested, we have O(n) instead of O(n^2).

The beginning is the same for both versions. A variable compareStrings is created which represents a function that takes in 2 parameters. We first eliminate the simplest case so if the strings match as they are then the return is “true”. If not, then 2 new empty arrays are created.

VERSION 1 CONTINUATION:

The letter “i” represents the index for the first argument and the string is iterated over. If the symbol “$” appears, then the last letter entered in the array is removed. If the item at that index is a letter, then it is added to the array. The same is done for the second argument except that the letter "j" is utilized. The arrays are then converted into strings and compared. If they are equivalent then ‘true” is returned, otherwise the return is “false”.

VERSION 2 CONTINUATION:

A variable loopLength is created and Math.max() is used to determine which argument’s length is longer. This is the number that the “i” which is the letter representing the index to iterate over the strings must be less than to ensure that even the longer string is completely iterated over. For each string it is first determined that the string is not undefined. If it is not then if the symbol “$” appears, then the last letter entered in the array is removed. If the item at that index is a letter, then it is added to the array. The same is done for the second argument. The arrays are then converted to strings and compared utilizing a ternary operator. If they are equivalent then ‘true” is returned, otherwise the return is “false”.

Please note that since “$” is eliminated, if that symbol appears at the beginning meaning that there were no letters to pop from the array, it will not change the “true” or “false” response.

Thanks for reading!

Building a Singly Linked List in JavaScript

DavidNNussbaum — Sun, 12 Dec 2021 17:38:06 +0000

Linked Lists are a linear collection of data elements whose order is not given by their physical placement in memory. Instead, it is a collection of nodes each one pointing to the next one which together represent a sequence. Each node consists of a pointer to the next node and a value that it contains. This value could be any type of data type. A singly linked list is unidirectional. The first node is called the head and the last node is called the tail and it points to null. Linked Lists represent a time saving over arrays in that with an array after the previously set size is reached an area of double the size is established in memory. In addition, when inserting or deleting items anywhere but at the end, all of the indices from the insertion point and onward must be changed. Both of these steps are time consuming for an array. Linked lists have an advantage over hash tables in that linked lists are ordered. A disadvantage that Linked Lists have compared to arrays is that the data is scattered in different memory locations and takes up more memory due to the pointers. Another disadvantage is that without indices, the nodes must be accessed sequentially.

In building the Linked List, it has nodes, the first one being the head and the last one being the tail. Each node has a value and a pointer which in the case of the tail points to null. We first create a class with a constructor that has a value as its parameter and has this.head containing a value which equals the argument value and the pointer (called “next”) equaling null since at the outset the head is also the tail. The length is initialized as 1. In order to be able to add a node, the append method is created. This method creates a variable called newNode which represents the new node and has a value of the argument value and next (the pointer) with a value of null (since this is the new tail). The tail is now updated to be the new node, and the length of the Linked List is increased by 1.

To demonstrate this, a new Linked List will be built with node values of 30, 18, and 22. If one wants to further build the Linked List, then it would involve additional methods which should be covered in a future posting.

The results in the terminal are as follows:

Thanks for reading!

A Quick Guide To Setting Up a Rails Directory

DavidNNussbaum — Sun, 05 Dec 2021 19:13:37 +0000

First create a new repo on github.

In your terminal, cd to the directory in which you want the rails directory to reside. Please note the words directory, file-name, YourName, ModelName, and column_name are being used as generic terms to be replaced with the actual names that you are using.

Now enter:
*~/directory$ rails new file-name -T --database=postgresql --no-test-framework *
Please note that if you do not enter -T --database=postgresql, to install PostgreSQL then the default database is SQLite.

If you do not enter --no-test-framework then the default is to include the extra test files.

Next cd to the created rails file:

~/directory$ cd file-name

The next steps will allow you to push your changes to github. Enter the following with everything after the word origin being a copy of the SSH from your github repo.

~/directory/file-name$ git remote add origin git@github.com:YourName/file-name.git

Next enter:

~/directory/file-name$ git branch

Followed by:
~/directory/file-name$ git status
The following will appear in the terminal:
On branch master

No commits yet

Next add (the period after a space is part of the entry):

~/directory/file-name$ git add .

Followed by:

~/directory/file-name$ git commit -m "Setting up the file."

Then enter:
~/directory/file-name$ git status
The following will appear in the terminal:
On branch master

nothing to commit, working tree clean

Next enter:

~/directory/file-name$ git branch -M master

Followed by:

~/directory/file-name$ git push -u origin master

Next enter:

~/directory/file-name$ git pull origin master --allow-unrelated-histories

Followed by:

~/directory/file-name$ git push --set-upstream origin master

If you are installing PostgreSQL enter, otherwise skip this step:

~/directory/file-name$ gem install pg

No matter what your database is the next step is:

~/directory/file-name$ bundle install

Followed by:

~/directory/file-name$ rails db:create

To set up each model enter:
~/directory/file-name$ rails g model ModelName column_name:type foreign_key:references
Please note that you can add in as many columns as are present for this model. The references term will create a column called whatever the foreign key is with _id attached.

Thanks for reading!

Tracking The Flow of Information in React.js

DavidNNussbaum — Sun, 15 Aug 2021 22:55:31 +0000

A major advantage of React is that it facilitates the overall process of writing components which can then in turn be reused. It can become challenging to track the flow of information from one component to another, especially when one wants to keep track of the props. Having a flow chart to be used as an available reference would allow a person to easily view the progression of information among the components. In this example, an actual React project will be utilized.

One would start in the parent component (which many times is App.js) and look at the components that are rendered within it. These components probably have props which are included to pass down. Here is an example:

src/componentsApp.js

App → Signup

App → Medications

src/components/Login.js

LoginForm is rendered. The flow chart is updated to the following.

App → Login → LoginForm(End)

App → Signup

App → Medications

LoginForm is opened and looking at the code reveals that it does not have any children so that line is complete. Any component without children are not shown in this post. We now go to Signup. When there are no children, (End) is entered to clarify that no component was left out of that progression.

src/components/Signup.js

SignupForm is rendered and therefore added to the list.

App → Login → LoginForm(End)

App → Signup → SignupForm(End)

App → Medications

SignupForm does not have any children so that line is complete. We now go to back to Medications. For the remainder of this posting, the logic will be continued. A progression will be followed and when a new progression is advanced, that will be an indication that the previous progression's last component had no children. If a branching occurs, every component up to that branching will be repeated.

src/components/Medications.js

App → Login → LoginForm(End)

App → Signup → SignupForm(End)

App → Medications → MedicationList

App → Medications → CreateMedication

src/lists/MedicationList.js

App → Login → LoginForm(End)

App → Signup → SignupForm(End)

App → Medications → MedicationList → Medication(End)

App → Medications → MedicationList → ComplicationList

App → Medications → CreateMedication

src/lists/ComplicationList.js

App → Login → LoginForm(End)

App → Signup → SignupForm(End)

App → Medications → MedicationList → Medication(End)

App → Medications → MedicationList → ComplicationList → Complication

App → Medications → MedicationList → ComplicationList → CreateComplication

App → Medications → CreateMedication

src/components/Complication.js

App → Login → LoginForm(End)

App → Signup → SignupForm(End)

App → Medications → MedicationList → Medication(End)

App → Medications → MedicationList → ComplicationList → Complication → EditComplicationForm(End)

App → Medications → MedicationList → ComplicationList → CreateComplication

App → Medications → CreateMedication

src/components/CreateComplication.js

App → Login → LoginForm(End)

App → Signup → SignupForm(End)

App → Medications → MedicationList → Medication(End)

App → Medications → MedicationList → ComplicationList → Complication → EditComplicationForm(End)

App → Medications → MedicationList → ComplicationList → CreateComplication → ComplicationForm(End)

App → Medications → CreateMedication

src/components/CreateMedication.js

App → Login → LoginForm(End)

App → Signup → SignupForm(End)

App → Medications → MedicationList → Medication(End)

App → Medications → MedicationList → ComplicationList → Complication → EditComplicationForm(End)

App → Medications → MedicationList → ComplicationList → CreateComplication → ComplicationForm(End)

App → Medications → CreateMedication → MedicationForm(End)

There is now a complete list of the progression of information which can be referenced during the building or usage of React.js programming.

Javascript Front End Coordination with Ruby Back End For User Sign Up and Log On

DavidNNussbaum — Thu, 10 Jun 2021 13:52:31 +0000

This posting will go through the steps that allow a Javascript front end to fetch user information from a Ruby API back end. Please note that JWT authentication is not being included and certainly should be if there is sensitive information being stored on the site. This particular site allows a user to sign in or to log on and then select from a list of doctors or add a doctor. The user can then add, edit, or delete their reviews, but view other peoples’ reviews without the ability to edit or delete them. We will start by setting up the Ruby API back end.

The first step is to activate gem 'bcrypt' and gem 'jsonapi-serializer' in the Gemfile and utilize bundle install.

The next step is to set up the model using rails g model User. In this case first_name, email, and password_digest are the attributes.

Here is a sample schema:

As you will notice, password_digest is the appropriate wording for the users table. Next, the user.rb model must be modified to reflect the flow of information.

The relationships have been set up, has_secure_password is present and the validations are included. The user_serializer.rb will now be viewed.

The serializer determines which attributes will be transmitted to the front end. The relationship between the user and the doctors they have commented on is established. One can see how the UserSerializer is utilized to help package the json data. Error messages have been created. The jsonapi-serializer gem that is being utilized forces us to include the word ”object” in the doctors method.

The users_controller.rb file is examined next.

Unlike pure rails, here in the API it is JSON that is rendered and the UserSerializer class that was previously created is utilized.

In the front end there are the getter functions associated with the user button as well as the log on, sign in and sign out getter functions.

Next the user model is created.

The form allows for the appropriate information to be entered and
input type="password" is used so that the password is hidden as it is entered. The constructor does not include the password because we don’t want it to appear in the front end.

The next file to look at is userApi.js.

Note that localStorage is used to hold the user’s information in the front end.

Once these steps have been completed, you should be ready to have a user sign in or log on through the front end.

Rails Coding to Allow Log In Via Either Google or Facebook – A Step By Step Guide.

DavidNNussbaum — Fri, 16 Apr 2021 21:08:30 +0000

The setting up of coding to allow a user to log in via Google or Facebook is a little more complicated due to differences in their structure.

The first step is to set up an account with the two sites. The following blog gives guidance regarding signing up with Google:

https://medium.com/@amoschoo/google-oauth-for-ruby-on-rails-129ce7196f35

The blog giving guidance for signing up with Facebook is:

https://dev.to/nkemjiks/implementing-facebook-authentication-with-devise-for-your-rails-6-app-1p3b

These two blogs give full instructions regarding the setting up of Google and Facebook developer accounts respectively. These should be followed. The ID and secret are the two pieces of information that you will need to use in your code. The blogs also explain how to set up the rails code for the use of either one but there are some minor changes necessary in order for there to be the option of using either Google or Facebook. That code is what will be discussed here.

Be sure to have ‘uid’, ‘image’, and ‘provider’ columns in your users table. If not, use a migration to add them.

When a screenshot is shown, the code regarding Omniauth is the only code that needs to be utilized.

The next step is to add the omniauth related gems in the gemfile and use bundle install.

Next Add the middleware to the project in config/initializers/omniauth.rb.

The next step is to add the following routes in config/routes.rb

Set up a controllers/omniauth_controller.rb file as follows:

The view allowing for usage of Google and Facebook would be set up as follows:

In config/routes.rb the following route would be used. In place of ‘social_media’, put in whichever view contains the link to Google and Facebook:

post '/sessions/social_media' => 'sessions#social_media'

Create a .env file. It is VERY IMPORTANT that you add this file to your .gitignore file so that the codes are not pushed to your github repository and viewed publicly, and set it up as follows, utilizing the ID and secret that you received from the Google and Facebook sites in place of the words ENTER YOUR CODE HERE.

Now you should be ready to allow users to log in with either Facebook or Google.

Being RESTful Is Not Always Best For The User

DavidNNussbaum — Mon, 15 Feb 2021 01:16:31 +0000

The RESTful convention has been invaluable regarding creating a consistency in the internet allowing for improved communication. However, as with most things in life, there are exceptions. My project involved having a page on which people can enter their medical histories and subjective reports. It would not be convenient for the user to enter part of the information on one page and then to proceed to the next page. This is separate from notes which a person may or may not make use of and therefore is appropriate to put on a separate page.

This is the page being discussed:

       Medical Information Notepad
       Medical Information For Peter

General History:
Medical Conditions:
Medications:
Allergies:
Current Treatments:
Surgeries:
Immunizations With Dates:
The Current Problem:
Location of the Problem:
Any Observed Changes:
What You Are Feeling:
What Is The Level Of Discomfort On A Scale Of 1 To 10:
How Long This Has Been Going On:
Press Here To Enter The Above Information:
Press Here To Logout Without Saving The Information:

The issue with this arrangement regarding the history and subjective areas is that they come from two separate tables. Therefore, the name on the route cannot be RESTful and simply use the name of the table since we have two tables represented on the page.
The schema is as follows:

create_table "comments", force: :cascade do |t|
t.text "identifier"
t.text "note"
t.text "items_to_discuss"
t.text "questions"
t.integer "patient_id"
end

create_table "histories", force: :cascade do |t|
t.text "diagnoses"
t.text "medications"
t.text "allergies"
t.text "current_treatments"
t.text "surgeries"
t.text "immunizations_with_dates"
t.integer "patient_id"
end

create_table "patients", force: :cascade do |t|
t.string "username"
t.string "password_digest"
end

create_table "subjectives", force: :cascade do |t|
t.text "location"
t.text "observed_changes"
t.text "sensation_changes"
t.string "scale_1_to_10"
t.text "length_of_time"
t.integer "patient_id"
end

end

This is the code for the page being discussed. As you can see, the two tables have their respective information entered separately even though two tables are being updated:

Medical Information Notepad

Medical Information For

<h3><u>General History:</u></h3>
Medical Conditions: <br> 
Medications: <br>
Allergies: <br>
Current Treatments: <br>
Surgeries: <br>
Immunizations With Dates: <br>

<h3><u>The Current Problem:</u></h3>
Location of the Problem:<br>
Any Observed Changes: <br>
What You Are Feeling: <br>
What Is The Level Of Discomfort On A Scale Of 1 To 10: <br>
How Long This Has Been Going On:<br>
<h3>

Press Here To Enter The Above Information:

    <h3>

Press Here To Logout Without Saving The Information:

Finally, the following code allows for the saving of information for both sections from the same page:

post '/patients/:id/info' do
redirect_if_not_logged_in
patient = Patient.find(session["patient_id"])
history = History.new(:diagnoses => params[:histories][:diagnoses])
history.medications = params[:histories][:medications]
history.allergies = params[:histories][:allergies]
history.current_treatments = params[:histories][:current_treatments]
history.surgeries = params[:histories][:surgeries]
history.immunizations_with_dates = params[:histories][:immunizations_with_dates]
history.patient_id = patient.id
history.save
subjective = Subjective.create(:location => params[:subjectives][:location])
subjective.observed_changes = params[:subjectives][:observed_changes]
subjective.sensation_changes = params[:subjectives][:sensation_changes]
subjective.scale_1_to_10 = params[:subjectives][:scale_1_to_10]
subjective.length_of_time = params[:subjectives][:length_of_time]
subjective.patient_id = patient.id
subjective.save

    redirect 'patients/:id/info'
end

As is evident from the above code, the route ends with /info which is not a RESTful term as /show would be. However, it does convey the meaning of what is presented on the page.

In conclusion, RESTful convention should indeed be used as frequently as possible. This presentation gives an example where being non-RESTful can be justified.

The examination of a JSON document utilizing Ruby: A Step-by-Step Guide

DavidNNussbaum — Mon, 14 Dec 2020 00:07:43 +0000

A person could have learned how to work with nested hashes and yet still find a JSON file to be overwhelming. A JSON file does not only contain multiple layers of nested hashes but can also contain arrays nested sporadically among the hashes. The following are the steps that can be taken to examine the JSON document in an organized manner.

           Step 1: Open your file.

In this overview an API to a JSON file will be utilized so that the reader can code along before moving on to a different JSON file. Obviously, the manner in which a file is opened will be determined by the exact location of the file. The code of binding.pry has been inserted so that the file can be examined in the terminal utilizing pry. Don’t forget to call the method in the file after creating it:

require 'net/http'
require 'open-uri'
require 'json'
require 'pry'

URL = "https://health.gov/myhealthfinder/api/v3/topicsearch.json?lang=en"

def get_info
uri = URI.parse(URL)
response = Net::HTTP.get_response(uri)
response.body

end

file = get_info
binding.pry

The following will appear in your terminal after running the file:

david@LT000568:~/projects/health-information-site$ ruby lib/test.rb
/home/david/.rvm/gems/ruby-2.6.1/gems/pry-0.13.1/lib/pry/editor.rb:19: warning: Insecure world writable dir /mnt/c in PATH, mode 040777

From: /home/david/projects/health-information-site/lib/test.rb:20 :

15:   
16:   end
17:  
18: 
19: file = get_info

=> 20: binding.pry

      Step 2: Determine the length of the file.

Note that all entries from now on are being done in the terminal which is open to pry. Remember that if necessary, the letter q should be entered to be ready for the next entry. file.length gives us the size of the file.

[1] pry(main)> file.length
=> 1332586
[2] pry(main)>

             Step 3: Parse the file.

One can examine more of the file by pressing on the down arrow as many times as one wants so examine as much of the file as is desired.

[2] pry(main)> data = JSON.parse(file)
=> {"Result"=>
{"Error"=>"False",
"Total"=>98,
"Query"=>
{"ApiVersion"=>"3",
"ApiType"=>"topicsearch",
"TopicId"=>nil,
"ToolId"=>nil,
"CategoryId"=>nil,
"PopulationId"=>nil,
"Keyword"=>nil,
"Who"=>nil,
"Age"=>nil,
"Sex"=>nil,
"Pregnant"=>nil,
"TobaccoUse"=>nil,
"SexuallyActive"=>nil,
"Category"=>nil,
"Lang"=>"en",
"Type"=>nil,
"ReturnType"=>"json",
"Callback"=>nil,
[3] pry(main)>

    Step 4: Determine the type of the overall file.

We will now use the .class method to confirm the type of the overall file. It is important to note that the “file” variable which is before the parsing is a string while the “data” variable which is after the parsing and which is what we are working with is a hash.

[3] pry(main)> data.class
=> Hash

        Step 5: Since this is a hash, use the .keys method 
                  to find the first one.

This step could really be skipped since the first key was revealed in step 3. It is just being mentioned because it is a simple starting point for what can be an overwhelming amount of data.

[4] pry(main)> data.keys
=> ["Result"]

        Step 6: Scroll down to find where the desired 
                 information is located.

Here entering “data”, one can scroll using the down arrow to the first line of desired information. In this case it was "Keep Your Heart Healthy".

[5] pry(main)> data
=> {"Result"=>
{"Error"=>"False",
"Total"=>98,
"Query"=>
{"ApiVersion"=>"3",
"ApiType"=>"topicsearch",
"TopicId"=>nil,
"ToolId"=>nil,
"CategoryId"=>nil,
"PopulationId"=>nil,
"Keyword"=>nil,
"Who"=>nil,
"Age"=>nil,
"Sex"=>nil,
"Pregnant"=>nil,
"TobaccoUse"=>nil,
"SexuallyActive"=>nil,
"Category"=>nil,
"Lang"=>"en",
"Type"=>nil,
"ReturnType"=>"json",
"Callback"=>nil,
"HealthfinderPage"=>nil,
"APiType"=>"topicsearch"},
"Language"=>"English",
"Resources"=>
{"Resource"=>
[{"Type"=>"Topic",
"Id"=>"25",
"Title"=>"Keep Your Heart Healthy",
"TranslationId"=>"25",
[6] pry(main)>

   Step 7: Start listing the keys necessary to reach the 
                   information.

One can see that there is a first key “Result” and that the desired line is arrived at by going to the key called “Resources” followed by the key called “Resource.” We can now consecutively enter a key and using the .keys method choose which of its contained keys we want to use. Note that the "Resources" key only has one key following it and that is "Resource". When we encounter a non-hash such as an array, the .keys method will generate a NoMethodError.

[6] pry(main)> data["Result"].keys
=> ["Error", "Total", "Query", "Language", "Resources"]
[7] pry(main)> data["Result"]["Resources"].keys
=> ["Resource"]
[8] pry(main)> data["Result"]["Resources"]["Resource"].keys
NoMethodError: undefined method `keys' for #Array:0x00007fffc58bdcc0
[9] pry(main)>

          Step 8: At the array, use indexing to find the 
                     desired information.

As we saw in step 6, the desired line is in the first hash within the array so this would be index 0. We will now examine the keys of that first hash in the array.
[9] pry(main)> data["Result"]["Resources"]["Resource"][0].keys
=> ["Type",
"Id",
"Title",
"TranslationId",
"TranslationTitle",
"Categories",
"Populations",
"MyHFTitle",
"MyHFDescription",
"MyHFCategory",
"MyHFCategoryHeading",
"LastUpdate",
"ImageUrl",
"ImageAlt",
"AccessibleVersion",
"RelatedItems",
"Sections",
"MoreInfoItems",
"HealthfinderLogo",
"HealthfinderUrl"]
[10] pry(main)>

      Step 9: Arriving at the desired information.

As seen in step 6, the desired line is the value for the “Title” key, so using it will allow us to arrive at the desired line.

[10] pry(main)> data["Result"]["Resources"]["Resource"][0]["Title"]
=> "Keep Your Heart Healthy"

         Step 10: Continue in the same manner until all 
                 information is obtained.

Just continue repeating the above steps until you have collected all the desired information. In my case the next desired information was not near the first piece, so it took several keys and indices to arrive at it.

[11] pry(main)>data["Result"]["Resources"]["Resource"][1]["Sections"]
["section"][0]["Title"]
=> "The Basics: Overview"
[12] pry(main)>

I hope that you found this posting to be helpful. Please let me know if you have any comments.

DEV Community: DavidNNussbaum

React Or Angular – Which Is Better? It Depends.

A Review Of Several Python Supervised Learning Classifiers With Some Of Their Advantages And Drawbacks

Creating A Hash Table

Prepending, Inserting, and Deleting Nodes In A JavaScript Singly Linked List

Using JavaScript To Compare Two Strings Containing Deleting Element(s) – Two Versions

Building a Singly Linked List in JavaScript

A Quick Guide To Setting Up a Rails Directory

In your terminal, cd to the directory in which you want the rails directory to reside. Please note the words directory, file-name, YourName, ModelName, and column_name are being used as generic terms to be replaced with the actual names that you are using.

If you do not enter --no-test-framework then the default is to include the extra test files.

~/directory$ cd file-name

~/directory/file-name$ git remote add origin git@github.com:YourName/file-name.git

~/directory/file-name$ git branch

No commits yet

~/directory/file-name$ git add .

~/directory/file-name$ git commit -m "Setting up the file."

nothing to commit, working tree clean

~/directory/file-name$ git branch -M master

~/directory/file-name$ git push -u origin master

~/directory/file-name$ git pull origin master --allow-unrelated-histories

~/directory/file-name$ git push --set-upstream origin master

*~/directory/file-name$ gem install pg *

~/directory/file-name$ bundle install

~/directory/file-name$ rails db:create

Tracking The Flow of Information in React.js

Javascript Front End Coordination with Ruby Back End For User Sign Up and Log On

Rails Coding to Allow Log In Via Either Google or Facebook – A Step By Step Guide.

Being RESTful Is Not Always Best For The User

end

Medical Information Notepad

Medical Information For

The examination of a JSON document utilizing Ruby: A Step-by-Step Guide

~/directory/file-name$ gem install pg