DEV Community: JJohnson45

Creating a pdf.file using react

JJohnson45 — Mon, 23 Mar 2020 16:30:37 +0000

Assuming your a mid level software developer, you know that react components are separated code that is better transmitted across UI and even through many other projects. This blog will discuss how to create a PDF component for your one of your projects.

Step 1 - Install Dependencies
First of all, I need an environment to create our component in. For this example I will be using create-react-app to generate a project. Navigate to an empty directory and run the following command:

npm i create-react-app --save-dev

Step 2 - Create the Project
Use the following commands to generate your React project:

npx create-react-app my-app
cd my-app
This will install React and any other dependencies you need.

Now you can start your local server by running:
npm run start

Navigate to http://localhost:3000/ and you should see the default create react-app welcome screen.

Step 3 - Project Setup
Next I need to set up our project. Start by clearing the templates that create-react-app provides. Navigate to src/App.js and delete all the code inside the render function, except the outer div. The file should now contain:

import React, { Component } from 'react';
import './App.css';
class App extends Component {
render() {
return (

);}}

export default App;

Now I need to create our PDF viewing component. Let’s create the file src/components/PDFViewer/PDFViewer.js and start by writing a basic React component.

import React from 'react';
export default class PDFViewer extends React.Component {

render() {
return (

Hello world!

)
}
}

Now, back in App.js, lets import this component and render it. App.js should now look like this:

import React, { Component } from 'react';
import './App.css';
import PDFViewer from './components/PDFViewer/PDFViewer';

class App extends Component {
render() {
return (

);
}
}

export default App;

If you take a look at http://localhost:3000 , you should see a little “Hello world!” on a white background.

Step 4 - Defining Our Backend
when creating your first backend that renders a PDF using pdf.js. Create the file src/backends/pdfjs.js and export a class that contains an init function.

export default class PDFJs {
init = () => {

}
}

Let’s make the init function accept both of these things as parameters.

export default class PDFJs {
init = (source, element) => {

}
}

In App.js, import the pdfjs.js backend and pass it as a prop to our PDFViewer component. We’re also going to need a PDF source, so lets pass that as well. App.js should now look something like this:

import React, { Component } from 'react';
import './App.css';
import PDFViewer from './components/PDFViewer/PDFViewer';
import PDFJSBackend from './backends/pdfjs';

class App extends Component {
render() {
return (

backend={PDFJSBackend}
src='/myPDF.pdf'
/>

);
}
}

export default App;

Now in our PDFViewer component, lets implement the backends init function. First we start by creating an instance of the backend and storing it to the component.

import React from 'react';

export default class PDFViewer extends React.Component {
constructor(props) {
super(props);
this.viewerRef = React.createRef();
this.backend = new props.backend();
}

render() {
return (

  </div>
)

}
}

No pass it a reference to the #viewer div , as well as the PDF source. We can also remove the "Hello world" from the render function while we're at it. PDFViewer.js should now look like this:

import React from 'react';

export default class PDFViewer extends React.Component {
constructor(props) {
super(props);
this.viewerRef = React.createRef();
this.backend = new props.backend();
}

componentDidMount() {
const { src } = this.props;
const element = this.viewerRef.current;

this.backend.init(src, element);

}

render() {
return (

  </div>
)

}
}

The final step is making our init function do something. Lets test it out by making it render some text.

export default class PDFJs {
init = (source, element) => {
const textNode = document.createElement('p');
textNode.innerHTML = Our PDF source will be: ${source};

element.appendChild(textNode);

}
}

http://localhost:3000 should now display "Our PDF source will be: /myPDF.pdf".

Step 5 - Implementing pdf.js
We will start by using the open sourced pdf.js library to render a PDF. Download the library from https://mozilla.github.io/pdf.js/getting_started/#download and extract the contents inside the public folder of our project.

src/backends/pdfjs.js should now look like this:

export default class PDFJs {
init = (source, element) => {
const iframe = document.createElement('iframe');

iframe.src = `/pdfjs-1.9.426-dist/web/viewer.html?file=${source}`;
iframe.width = '100%';
iframe.height = '100%';

element.appendChild(iframe);

}
}

If you check out http://localhost:3000, you should see your PDF displayed inside the pdf.js viewer.

Artificial Intelligence

JJohnson45 — Mon, 16 Mar 2020 13:25:43 +0000

Artificial Intelligence (AI) is a branch of Science which deals with helping machines find solutions to complex problems in a more human-like fashion. The interdisciplinary field of cognitive science brings together
computer models from AI and experimental techniques from psychology to construct precise and testable theories of the human mind. This generally involves borrowing characteristics from human intelligence, and applying them as algorithms in a computer friendly way. A more or less flexible or efficient approach can be taken depending on the
requirements established, which influences how artificial the intelligent behavior appears. Artificial intelligence can be viewed from a variety of perspectives. From the perspective of intelligence
artificial intelligence is making machines "intelligent" -- acting as we would expect people to act. The inability to distinguish computer responses from human responses is called the Turing test. Intelligence requires knowledge expert problem solving - restricting domain to allow including significant relevant knowledge.

From a programming perspective, AI includes the study of symbolic
programming, problem solving, and search.
o Typically AI programs focus on symbols rather than numeric
processing.
o Problem solving - achieve goals.
o AI programming languages include:
– LISP, developed in the 1950s, is the early programming language
strongly associated with AI. LISP is a functional programming language with procedural extensions. LISP (LISt Processor) was specifically designed for processing heterogeneous lists -- typically a list of symbols.

Features of LISP
are run- time type checking, higher order functions (functions that have other functions as parameters), automatic memory management (garbage collection) and an interactive environment. Also, Object-oriented languages are a class of languages more recently used for AI programming. Important features of object-oriented languages include: concepts of objects and messages, objects bundle data and methods for manipulating the data, sender specifies what is to be done receiver decides how to do it, inheritance (object hierarchy where objects inherit the attributes of the more general class of objects). Examples of object-oriented languages are Smalltalk, Objective C, C++.

Artificial Intelligence is a new electronic machine that stores large amount of information and process it at very high speed. The computer is interrogated by a human via a teletype It passes if the human cannot
tell if there is a computer or human at the other end. The ability to solve problems. It is the science and engineering of making intelligent machines, especially intelligent computer programs. It is related to the similar task of using computers to understand human intelligence.

Importance of AI
Game Playing
You can buy machines that can play master level chess for a few hundred dollars. There is some AI in them, but they play well against people mainly through brute force computation--looking at hundreds of thousands of positions. To beat a world champion by brute force and known reliable heuristics requires being able to look at 200 million positions per second.

Speech Recognition
In the 1990s, computer speech recognition reached a practical level for limited purposes. Thus United Airlines has replaced its keyboard tree for flight information by a system using speech recognition of flight numbers and city names. It is quite convenient. On the other hand, while it is possible to instruct some computers using speech, most users have gone back to the keyboard and the mouse as still more convenient.

Understanding Natural Language
Just getting a sequence of words into a computer is not enough. Parsing sentences is not enough either. The computer has to be provided with an understanding of the domain the text is about, and this is presently possible only for very limited domains.
The world is composed of three-dimensional objects, but the inputs to the human eye and computers' TV cameras are two dimensional. Some useful programs can work solely in two dimensions, but full computer vision requires partial three-dimensional information that is not just a set of two-dimensional views. At present there are only limited ways of representing three-dimensional information directly, and they are not
as good as what humans evidently use.

Redux

JJohnson45 — Mon, 09 Mar 2020 12:46:04 +0000

Redux is a JavaScript library for application state management. Redux-Saga is a middleware from the Redux library that allows for the application side effects to be easier to manage, control, and test. The architectural model describes the control flow in the system. While separation of concerns is achieved through a modular structure. Modeling the use cases of the system as sagas makes them more readable and supports automated testing. The implementation of the architecture is described through code listings. One of the most important attributes of a software codebase is the readability of the code. When we're talking about a software project that lasts for many years and has a large amount of developers working on it the readability of the code will have a important effect on the speed and quality of the development effort. Developers are constantly reading old code when they are developing new code. Managing the application state and control flow properly has a huge impact on the readability. If the codebase and the flow of control in the application is easy to follow and understand for the developers, then developing new features or fixing existing bugs will be faster and less error prone.

Architectural complexity has detrimental effects on development productivity. Reducing the complexity of the software will also definitely help alleviate the burden on the developers allowing them to be more productive as well as less frustrated in
their work. And of course, all the time saved on development work can be directly mapped to cost savings as well. It is important to be able to automatically test as many parts of a system as possible.
New technologies, techniques and tools are constantly being introduced for handling common challenges in the field of software development field. So, most of the time there will be a very limited amount of research available. In Redux-saga 8 introduces a new kind of a pattern for handling application side-effects and flows. Proper state management is vital for keeping track of all the data in your application. Failing
to do so will most likely result in some kind of problems during the development of the software. Some of the most common problems are issues with duplicate and out-of-sync data. Letting the application to get into that kind of a state will increase the effort it takes to maintain the software and it will most likely also introduce bugs along the way. It is hard work to try to manage multiple instances of a single piece of data and developers – being human – tend to miss some of the instances when making modifications to the codebase. Worst case scenario is that you might end up with presenting or storing wrong data if there are multiple instances of the supposedly same piece of data.

You can keep your application much simpler if you take care and make sure there is a single source of truth for the data. A successful software project must focus on the needs of a customer. There are different
ways of modeling out the domain to make sure you are truly developing something that produces value for the customer. Good architecture should be one that enables the use of different domain models and supports the developers in implementing the required features and use
cases. In other words, the architecture should provide a proper way for handling pieces of the application logic and use case workflows.

BackBone Js

JJohnson45 — Mon, 10 Feb 2020 15:17:59 +0000

Let's assume you're a skilled JavaScript front-end developer or just diving into the world of frameworks, you've definitely heard of Backbone.js. Backbone.js is a outdated but still useful and unique framework. This blog post is here to give you an insight on Backbone.js. After reading this guide, you should learn what this framework is, it's features and how to get started.

Backbone.js, often referred to as Backbone, is an open-source JavaScript library aimed to provide a structure to client-side web applications based on the Model-View-Controller (MVC) design pattern. This allows for communication between the client and server to be carried out through restful API's.

Web applications used to be static HTML pages and required programmers to change the HTML, CSS and JS code just to make its changes in the content. But with advancement of server-side programming languages, these static HTML pages have became dynamic. Therefore, most web applications use this approach today.

However, there is a main problem with this approach. It's the heavy use of JavaScript, that makes the application code extremely difficult to organize and maintain. That’s where Backbone.js fixes the problem. It provides developers a more organized approach to build JavaScript-heavy web applications.

Backbone models contain data for an application as well as the logic around this data. Models can be created by extending Backbone.Model

The initialize() method is called when a new instance of a model is created.

Model.get() provides easy access to a model’s attributes.

Model.set() sets a hash containing one or more attributes on the model. When any of these attributes alter the state of the model, a “change” event is triggered on it.

Backbone views are used to reflect what your applications' data models look like. They are also used to listen to events and react accordingly.
Views in Backbone don’t contain the HTML for your application.
Instead, they contain the logic behind the presentation of the data to the user. A view’s render() method can be bound to a model’s change() event. Allowing for the view to instantly reflect model changes without requiring a full page refresh.

Controller.extend() can be used to do class inheritance. So your controllers(collections) are able to share functionality from their parent controller(collections).

Collections have many methods suchAs:
add (model, collection, options)
remove (model, collection, options)
reset (collection, options)
sort (collection, options)

Backbone collections are simply an ordered set of models. Such that it can be used in situations such as;

Model: Student, Collection: ClassStudents
Model: Todo Item, Collection: Todo List
Model: Animal, Collection: Zoo
Typically your collection will only use one type of model but models themselves are not limited to a type of collection;

Model: Student, Collection: Gym Class
Model: Student, Collection: Art Class
Model: Student, Collection: English Class

Normally, when creating a collection you’ll want to define a property specifying the type of model that your collection will contain, along with any instance properties required.
Creating a backbone collection is similar to creating a model. We just need to extend the backbone’s collection class to create our own collection.
var HorseCollection = Backbone.Collection.extend({});

This collection will hold the Horse model we have created in our previous articles.

Specifying the model for a collection.

To specify which model this collection should hold, we need to specify/override the model property of the collection class.

var HorseCollection = Backbone.Collection.extend({
model: Horse,
});

Once we specify the model property of a collection what will happen internally is that whenever we create this collection, internally it will create an array of the specified models. Then all the operations on this collection object will result in the actual operations on that array.

Instantiating a collection.

A collection can be instantiated by using the new keyword. We can create an empty collection and then add the model objects to it later or we can pass a few model objects in the collection while creating it.

var collection1 = new HorseCollection();
//pre-populated collection
var Horse1 = new Horse({ color: Black, HorseName: "Tony" });
var Horse2 = new Horse({ color: Tan, HorseName: "Ralph" });
var collection2 = new HorseCollection([Horse1, Horse2]);

Adding items to the collection.

To add an item to a collection, we can use the add method on the collection.

var Horse3 = new Horse({ color: white, HorseName: "Ally" });
collection2.add(Horse3);
Now there might be a scenario where we actually want to update an existing added model in a collection. If that is the case, then we need to pass the {merge: true} option in the add function.

var horse3_changed = new Horse({ color: brown, HorseName: "Changed Horse"});

collection2.add(horse3_changed, { merge: true });

Also, if we want to add multiple models, we can do that by passing the model array in the add method.

var horse4 = new Horse({ color: black, HorseName: "Christina" });
var horse5 = new Horse({ color: brown, HorseName: "Meg" });
collection2.add([horse4, horse5]);

It is also possible to add the model at a specific index in the collection. To do this we need to pass the {at: location} in the add options.

var horse6 = new Horse({ color: white, HorseName: "riq" });
collection2.add(horse6, {at:0});

Removing models from collection
To remove the model from the collection, we just need to call the remove method on the collection. The remove method simply removes this model from the collection.
collection2.remove(Horse6);

Also, if we want to empty the model, we can call the reset method on the collection.

collection1.reset();
It is also possible to reset a collection and populate it with new models by passing an array of models in the reset function.

collection2.reset([horse4, horse5]); // this will reset the collection //and add horse4 and horse5 into it
pop and shift function can also be used to remove model from collection.

Finding the number of items in collection

The total number of items in a collection can be found using the length property.
var collection2 = new HorseCollection([horse1, horse2]);
console.log(collection2.length); // prints 2

Retrieving models from collection
To retrieve a model from a specific location, we can use the at function by passing a 0 based index.

var horseRecieved = collection2.at(3);
Alternatively, to get the index of a known model in the collection, we can use the indexOf method.

var index = collection2.indexOf(horseRecieved);
We can also retreive a model from a collection if we know its color or name. this can be done by using the get function.

var HorseFetchedbyColor = collection2.get(brown); // get the horse with color=brown
If we want to iterate through all the models in a collection, we can simply use the classic for loop or the each function provided by collections which is very similar to the foreach loop of underscore.js.

for (var i = 0; i < collection2.length; ++i) {
console.log(collection2.at(i).get("HorseName"));
}
collection2.each(function (item, index, all) {
console.log(item.get("HorseName"));
});

no sql vs sql

JJohnson45 — Mon, 03 Feb 2020 13:49:32 +0000

A NoSQL is a Non-relational database likely to be more distributed than structured whereas a SQL Database is a Relational Database and a structured one

You might ask what exactly mean Relational Database?
Relational database strictly is where the set of rows and columns to store data often named as tables, but the Non-relational database has a distributed storage which doesn’t require any table structure.
NoSQL databases have a dynamic schema for document type or unstructured data whereas SQL Databases have a well-designed pre-defined schema.

SQL databases are vertically scalable whereas NoSQL databases are horizontally scalable. You can scale the SQL databases by expanding the strength of its hardware. Also, when it comes to NoSQL databases you can scale it by expanding the database servers.

While SQL uses structured query language for defining data, NoSQL uses the collection of documents which is also known as Unstructured Query Language.

We can easily add the new data in NoSQL without requiring prior steps whereas SQL might require doing some changes like backfilling data, altering schemas.

Since SQL has a standard interface for handling complex queries, it would be great to deal with complex queries. however, in noSql it’s quite difficult to handle complex queries in NoSQL.

MySQL, differences between SQL and NoSQL databasesMySQL are compatible for creating both small and large-size applications.
Help you to create a replica of Database to reduce the workload. Increased Scalability. Allow you to divide the databases into small chunks to make use of low-level servers.

Oracle an object-relational database that helps you to achieve great customer service and reliability. It provides great platform support. Better scalability and Reliable.

the enhanced Dynamic schema you can improve your data without affecting the existing data.
It provides excellent scalability and high performance.

It will allow you to access your databases through the web browser.Apache CouchD difference between Sql and Nosql
More flexible and easy replication.

Also, great support is available for all SQL database. Also a lot of independent developers are there who can help you with SQL database for a very large scale deployments but for some NoSQL database you still have to rely on community support and only limited outside experts are available for setting up and deploying your large scale NoSQL deployments.

Some examples of SQL databases include PostgreSQL, MySQL, Oracle and Microsoft SQL Server. NoSQL database examples include Redis, RavenDB Cassandra, MongoDB, BigTable, HBase, Neo4j and CouchDB.

In most cases, All the businesses will lean on both databases. NoSQL database might have high popularity due to its high scalability and speed, but still, there would be a highly inescapable situation for businesses to use the SQL database

SQL actively protects the integrity of your database by providing ACID compliance. Due to its structured data, you will not require any integrated system support for using various types of data.
Moreover, SQL is the highly preferable option for so many businesses due to its predefined structure and schemas.
Why use NoSQL database?
It’s getting popularity by allowing you to store different data types together and you can easily scale by spreading around multiple servers.
If you are in need of developing an application within a speculated time, then you can go for NoSQL which will speed up your performance with its rapid development phase.

Everyone will have their own preferences based on the project requirements.If you are in need of NoSQL today, it doesn’t mean that it will be stick on to it all day.
There might be different preferences, distinct requirements to prefer over some other database.

Vr vs Ar. Which should I choose?

JJohnson45 — Mon, 27 Jan 2020 13:44:54 +0000

Augmented reality and virtual reality are often confused. Let’s explain both in plain terms and examine some AR and VR use cases.

Augmented reality (AR) and virtual reality (VR) are often talked about in the same breath . AR and VR do share a lot of commonalities.

For people who’ve never actually seen an AR or VR device, it's very easy to assume everything is VR.
However, AR and VR today are two distinct thingsVR gets much more coverage.

Since AR and VR are not one and the same, they require different strategies for implementing these technologies in their organizations. Let's clarify the differences and look at some real-world examples.

AR vs. VR: Key differences
AR lets the user experience the real world, which has been digitally augmented or enhanced in some way. VR, on the other hand, removes the user from that real-world experience, replacing it with a completely simulated one.

Because VR requires complete immersion, VR devices shut out the physical world completely. The lens on the smart glasses that deliver AR capabilities, on the other hand, are transparent. Understanding these differences is critical in determining the best use cases for each.
Many people have already experienced virtual reality games, and VR is of growing importance for training and education in fields like medicine, engineering, and the sciences. Some of the world’s leading technology companies — including Microsoft, Sony, Google, Facebook, Apple, and Samsung — are spending heavily to develop VR equipment and applications.

In its simplest forms, virtual reality is experienced as 3D graphics, images, or 360-degree videos on computers or smartphones running mobile apps. More elaborate VR systems use wraparound computer displays or even entire rooms with high-resolution displays integrated into the walls.

AR vs. VR use cases
At a high level, AR applications are best suited for use cases where users need to be connected to and present in the real world. Some AR enterprise solutions include remote assistance, on-the-job training, remote collaboration, and computer-assisted tasks.

Research has found AR to be well-suited for industrial use cases, particularly workforce training and product maintenance. In particular, companies that are facing knowledge gaps and expertise loss as workers retire are capturing that knowledge and sharing it with less-experienced workers via AR tools.

Maintenance professionals create AR headsets to record and narrate their tasks – which will then be used to train new workers.
One example: Honeywell is dealing with an aging workforce. Instead of writing out training documents, its maintenance professionals created AR headsets to record and narrate their tasks – which will then be used to train mew workers in a hands-on but digitally assisted way. The company says workers trained in this fashion tend to retain 80 percent of what they’ve learned, compared to 20 to 30 percent when they read a manual.

VR applications are best suited for simulation or complete immersion: For example remote collaboration with 3D elements, point-of-view training, and virtual tours. The Johnson & Johnson Institute, for example, developed virtual reality software to improve training for orthopedic surgeons and nurses. Walmart uses VR to create both unlikely scenarios (such as weather emergencies) and common ones to give associates a first-hand training experience without disrupting operations.

During the next three to five years, AR and VR will continue to be applied in different ways. They serve different purposes and offer different value propositions. However, if wearables become more mainstream in the enterprise, these capabilities may converge more with time.

What is mongoDB and how to get started.

JJohnson45 — Mon, 20 Jan 2020 13:11:41 +0000

In this article I will share how to build Restful API with Nodejs Express MongoDB

In order to develop and run this restful API, we need Node.js, which is JavaScript runtime installed on our machine. With Node.js comes NPM which is a node package manager that we will use to install other packages like Express needed to develop this API.
Also, we need to have MongoDB installed on the machine.

MongoDB Installation/Setup
MongoDb is a no-SQL database that stores data in the form of JSON object which is called Document. All Documents are stored in the container called Collection. So first Collection is created and then Document in inserted into it.

Get Started…
Start with creating project folder.

$ mkdir webapi

$ cd webapi

Now we will start with creating package.json file which is the first building block for Node.js application and holds application configuration and package dependencies details that is required in order to run the application.

$ npm init --yes

Install Express, Mongoose and body-parser

Mongoose is a MondoDB object data modelling package that provides a straight-forward, schema-based solution to model data in the Node.js application.
body-paser is Node.js middleware for parsing incoming request bodies in a middleware before request handlers and is available under the req.body property.

So install all these packages by running following command in the command window.

$ npm i express mongoose body-parser –save

–save option will add entry for these packages in the dependencies section in package.json file for our project.

Write Code…
Now open the code editor to start writing code.

Create db.js file and add following code to create and export connection with MongoDB using mongoose.

const mongoose = require("mongoose");
mongoose.connect(
"mongodb://localhost:27017/customerDb",
{ useNewUrlParser: true, useUnifiedTopology: true },
err => {
if (!err) console.log("Successfully connect to MondoDB...");
else
console.log(
"Connection to MongoDb failed :" + JSON
.stringify(err, undefined, 2)
);
}
);

module.exports = mongoose;

Create index.js file and add following code to create Express server to host our restful API. It will also import mongodb connection from db.js.
const bodyParser = require("body-parser");
const { mongoose } = require("./db");
const customer = require("./Controller/CustomerController");

const express = require("express");
const app = express();

//added middleware code
app.use(bodyParser.json());
app.use("/customers", customer);

const port = process.env.port || 3000;
app.listen(port, () => {
console.log(server listening at port :${port});
});
Now we need to create object data model to store Customer data in the MongoDB database. So create schema folder and create Customer.js file in it. Add following code to hold Customer model schema and export it as well.
const mongoose = require("mongoose");

var Customer = mongoose.model("Customer", {
first_name: String,
last_name: String,
gender: String,
age: Number,
email: String
});

module.exports = { Customer };
The last piece of code is to add controller code that will expose our restful API endpoints. So create Controller folder and in it create CustomerController.js file.

Now add following code for CRUD operations.

Add following code to handle GET request to fetch the Customers.
router.get("/", (req, resp) => {
Customer.find((err, docs) => {
if (err)
console.log(
"Error while getting customers..." + JSON
.stringify(err, undefined, 2)
);
else resp.send(docs);
});
});

To create new Customer, add following code to handle POST request from the client.
router.post("/", (req, resp) => {
let cust = new Customer({
first_name: req.body.first_name,
last_name: req.body.last_name,
gender: req.body.gender,
age: req.body.age,
email: req.body.email
});
cust.save((err, doc) => {
if (err)
console.log(
"error in saving customers..." + JSON
.stringify(err, undefined, 2)
);
else resp.send(doc);
});
});

Launch the API
Now run following command to host our restful API.

$ node index.js

It will launch the web server that will host our API available at http://localhost:3000/Customers

Test the API
Now open the Postman Web API Client application and click on the Create a request to initiate an API request to our restful API.

Take following steps to test POST request handler to create the Customer.

Select POST HTTP verb from the drop down.
Enter request URL http://localhost:3000/Customers for post request.
Select Body tab and then select raw radio button and finally select type JSON from the drop down.
In the request body enter following JSON object representing our Customer resource that we want to create.
{
"first_name" : "Amit",
"last_name" : "Patil",
"gender" : "Male",
"age" : 39,
"email" : "Amit@gmail.com"
}

MySql? What is it?

JJohnson45 — Mon, 16 Dec 2019 05:04:39 +0000

MySQL is an open source relational database management system (RDBMS) with a client-server model. RDBMS is a software used to create and manage databases. The application MySQL is used for a wide range of purposes, including data warehousing, e-commerce, and logging applications. It is most noted for its quick processing, proven reliability, ease and flexibility of use. MySQL is an essential part of almost every open source PHP application.

For example, WordPress requires MySQL to store and retrieve all of its data including post content, user profiles, and custom post types. Most web hosting providers already have MySQL installed on their web servers as it is widely used in many open source web applications such as WordPress.

The most common use for mySQL however, is for the purpose of a web database. It can be used to store anything from a single record of information to an entire inventory of available products for an online store.

Database
A database is simply a collection of structured data. Think of taking a selfie: you push a button and capture an image of yourself. Your photo is data, and your phone’s gallery is the database. A database is a place in which data is stored and organized. The data stored in the dataset is organized as tables. Every table relates in some ways.

Open source
Open source means that you’re free to use and modify it. Anybody can install the software. You can also learn and customize the source code to better accommodate your needs. However, The GPL (GNU Public License) determines what you can do depending on conditions. The commercially licensed version is available if you need more flexible ownership and advanced support.

Client-server model
Computers that install and run RDBMS software are called clients. Whenever they need to access data, they connect to the RDBMS server. That’s the “client-server” part.

MySQL is one of many RDBMS software options. RDBMS and MySQL are often thought to be the same because of MySQL’s popularity. Even though it was initially created for limited usage, now it’s compatible with many important computing platforms like Linux, macOS, Microsoft Windows, and Ubuntu.

SQL
MySQL and SQL are not the same. Be aware that MySQL is one of the most popular RDBMS software’s brand name, which implements a client-server model. The client and server communicate in an RDBMS environment by using a domain specific language – Structured Query Language (SQL). RDBMS software is often written in other programming languages, but always use SQL as their primary language to interact with the database. MySQL itself is written in C and C++.

Ted Codd developed SQL in the early 1970s. It became more widely used in 1974 and quickly replaced ISAM and VISAM. SQL tells the server what to do with the data. It is similar to your WordPress password or code. You input it into the system to gain access to the dashboard area. In this case, SQL statements can instruct the server to perform certain operations:

Data query: requesting specific information from the existing database.
Data manipulation: adding, deleting, changing, sorting, and other operations to modify the data, the values or the visuals.
Data identity: defining data types. This also includes defining a schema or the relationship of each table in the database
Data access control: providing security techniques to protect data, this includes deciding who can view or use any information stored in the database

Node JavaScript

JJohnson45 — Mon, 09 Dec 2019 05:28:49 +0000

Node JavaScript is the system that allows you to utilize the Javascript skills outside of the application. Combined you can create anything code line to HTTP hosts that power active sites. Node.js can generate dynamic page content, can create, open, read, write, delete, and close files on the server. It has the ability to collect form data, as well as add, delete and modify data in your database. There is a difference in how Node.js handles a file request between how PHP or ASP handles a file request. In regards to PHP or ASP, they send the task to the computer's file system and wait while the file system opens then reads the file. Subsequently, they return the content to the client ready to handle the next request.

How Node.js handles a file request is much more efficient simply because it eliminates the waiting, and simply continues with the next request. It initially sends the task to the computer's file system. Afterward, it is ready to handle the next request. When the file system has opened and read the file, the server returns the content to the client. Running single-threaded, non-blocking, asynchronously programming, making it to be very memory efficient.

Node was initially believed for the use of making asynchronous programming simple and accessible. JavaScript lends itself well to the structure similar to Node. It is one of those few programming languages that does not get the built-in means to do in- and output production. Therefore, JavaScript would be well onto the Node’s rather eccentric approach to in- and output without turning out with two contradictory interfaces.

When Node was being designed back in 2009, people were already performing call-back based programming at the application, so the people in the word were accustomed to the asynchronous programming style. This console.log method does something similar to what it does in this browser. It prints out the piece of text. Rather than going to the browser's JavaScript table, in Node the text can go to the process's basic output flow.

When working node from the command line, this means you find the logged values in your station or terminal. Node is the newest programming language and APIs. It runs with JavaScript but is not JavaScript itself, Node is the system that you consume Javascript. It is so common because you can write the server without learning other methods. With all of its advantages, Node.js now plays a critical role in the technology stack of many high-profile companies who depend on its unique benefits.

Another big difference is that in Node.js you control the environment. You know which version of Node.js you will run the application on unless you are building an open-source application that anyone can deploy anywhere. This is very convenient Compared to the browser environment, where you don't get the luxury to choose what browser your visitors will use.

Node.js is a platform built on Chrome's JavaScript runtime for easily building fast, scalable network applications. Using an event-driven, non-blocking I/O model makes it lightweight and efficient, which is perfect for data-intensive real-time applications that run across distributed devices. Event-driven means that the server only reacts when an event occurs. This allows us to create high performance, highly scalable, “real-time” applications.

Introductory To Angular JS

JJohnson45 — Tue, 03 Dec 2019 17:30:36 +0000

As mentioned before frameworks provide a set of guidelines for building your application. Unlike libraries, that are sets of useful functionality that's contained in JavaScript files. AngularJS is an example of a framework that is used for building an application. When you choose a framework it may drive a portion of the application design because certain aspects of the framework needs to be in place for it to function properly.

Angular JS is commonly referred to as a Single Page Application (SPA). This is because the interaction and application logic all are on one single page. This single page also loads new data and content dynamically. This framework simplifies the process of building single page applications. Some of it's features include data -binding, client-side templating and AJAX wrappers for accessing data. AngularJS was designed to be testable end-to-end. It uses Dependency Injection to make replicating objects simple. It is also designed to encourage you to break the functionality of your application into several smaller, more testable parts.

AngularJS provides a set of constructs to reduce the amount of code and effort involved in making an application work properly. It's also Model-View-Controller (MVC) framework because it takes a modular approach to building your applications.

View: In this layer, we have the code related to what the user experiences, with pages and rules related to navigation.

Controller: This layer is the code that bridges between the navigation and the source of application data, represented by the model layer. Processing and business rules typically belong to this layer.

Model: In this layer is the code responsible for performing the persistence of the application data.

Each view is established in HTML. And these Views have a JavaScript controller module and model that drive the interaction. There is a JavaScript file that contains a controller. And in that file there's a specific constructor function that will be used to create the actual controller instance. The purpose of controllers is to create variables and add functionality to expressions and directives.

There is also an ng-controller directive to the HTML. This directive tells AngularJS that the new InvoiceController is responsible for the element with the directive and all of the element's children. The syntax InvoiceController tells AngularJS to instantiate the controller. And once it was instantiated save it in a variable invoice, that's in the current scope.

The possible occurrences of that directive are defined in the controller and added to the template using ng-repeat.

In AngularJS, a service is a function that 's available in your AngularJS application.

AngularJS has about 30 built-in services. For many services, it seems like you could use objects that are already in the DOM, even though you could it would have some limitations, at least for your AngularJS application.

AngularJS constantly supervises your application, and for it to handle changes and events properly, AngularJS prefers that you use the built in services. The $http service is one of the most common used services in AngularJS applications. The service makes a request to the server, and lets your application handle the response.

And so I conclude my post on Angular JS. With it having design flexibility and an easy to use structure, this single page applications model is a powerful tool that every web developer should have in his portfolio. Thanks to everyone who viewed this post. Till next time!