Best match

Most recent

A Vision

Future

Deep learning

Deep learning has emerged as a revolutionary technology within data science, enabling businesses to extract valuable insights from their data like never before. In the era of data-driven technology, deep learning offers businesses a competitive advantage ...

Unleashing the Power of Deep Learning in 2023: A Vision for AI’s Future

Impacts

Get the most recent info and news about HarperDB on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

HarperDB is a SQL/NoSQL data management platform. It is fully indexed, doesn’t duplicate data, and runs on any device- from the edge to the cloud.

HarperDB

HackerNoon Reporter: Please tell us briefly about your background. I started programming when I was 13 years old working for my uncle’s startup that did ISP billing in the 90s. I worked for Red Hat running infrastructure for global support services, and have founded a few startups and worked at others. What's your startup called? And in a sentence or two, what does it do? HarperDB is a globally distributed database focused on making developers' lives easier while providing capability for low latency applications. What is the origin story? Kyle Bernhardy, our CTO, and I have been solving big data and integration challenges for over a decade. We met at a company called Coresite where we were locked in a small conference room for a month working on a project. Since then he and I have worked together through 4 companies and along the way picked up several other amazing folks. We have continued to work on large scale and complex data projects. Ultimately we realized that the vast majority of the problems we were faced with in analytics, code, middleware, etc. were created by the database. Furthermore, we felt like databases were overly complex, and even though they are frequently used by developers, they were not developer friendly. We wanted to build a product with the flexibility of NoSQL and the analytical capability of SQL while being super easy to scale and incredibly developer friendly. Our goal was to enable a brand new developer to confidently build a globally distributed scalable application with HarperDB as the back-end. What do you love about your team, and why are you the ones to solve this problem? Our team is amazing, and the core team has worked together for a very long time. This has allowed us to build a really strong company culture. Everyone gets along extremely well and embodies our core values. We look for people who we can empower that are authentic, transparent, kind, and capable of taking accountability. I think we are the ones to solve the problem because we were determined and far too stupid to know what we were getting into. Building a database is hard. Much harder than we expected. We are not MIT grads, we didn’t take any classes from Andy Pavlo at CMU on databases, and that is exactly what makes our product unique and awesome. Kyle has a degree in exercise management and mine is in theology. Had we known what we were getting into we wouldn’t have done it. We also would have brought a mindset to the problem that wouldn’t have really added anything new to the space. While HarperDB started as a database it has really morphed into an edge development platform. We built the product we would want to use and I think that shows. If you weren’t building your startup, what would you be doing? Stand up comedy? At the moment, how do you measure success? What are your core metrics? We look at a variety of things. Obviously typical metrics like number of customers, quality of customers, ARR and MRR, but we are also looking at things like freemium adoption on npm and HarperDB Cloud, our ranking in db-engines month over month, and a number of other factors. What’s most exciting about your traction to date? Being featured on HackerNoon? Aside from that, watching developers build amazing products all over the world on top of HarperDB is my favorite part. Watching developers on social media find HarperDB and get excited by it keeps the whole team going. What technologies are you currently most excited about, and most worried about? And why? I am not really worried about any technology, I am of the mindset that all technological advancement is exciting. That said, what people do with it can obviously be scary, but that is a different matter. Specifically for HarperDB we are pretty excited about CRDTs and the capability that will be gained by adding that to HarperDB’s replication. I am also super excited about the release of HarperDB Custom Functions which will give developers the ability to build their entire stack on HarperDB! What drew you to get published on HackerNoon? What do you like most about our platform? Margo, our head of dev rel made me? Just kidding. First and foremost I like the font. I am a bit older and the font makes me feel at home! In addition, I think that the broad range of topics covered that encompass the entire startup journey from a technical perspective is interesting and important. What advice would you give to the 21-year-old version of yourself? You are not that smart. Be humble. Sales are just as important as product, because if you build an amazing product but can’t sell it you don’t have a company. Listen to feedback, no matter how smart you think you are, it doesn’t matter if the world wants something else. Meet people where they are, not where you want them to be. Being kind is easy and much more effective than being an asshole. Hiring cool people and teaching them what they need to know is more effective than hiring really talented Premadonna's. Vote for HarperDB as the . startup of the year from Denver, Colorado

The Importance Of Staying Humble And Strong Company Culture: Stephen Goldberg, HarperDB CEO

Learn how to use these two technologies together to build a REST API This article will teach you how to use Node.js, Fastify and HarperDB to build a course management system. This application will help you track the courses you are doing and the courses you plan to do. You will use the following technologies: Node.js HarperDB Fastify Introduction When it comes to Node.js and Fastify, people are familiar with these technologies. However, when it comes to databases, there is a new kid on the block! Recently, I took a break from the databases I usually use to play around with HarperDB. is a distributed database with NoSQL and SQL capabilities. The thing about HarperDB is that you perform all the CRUD database operations using one endpoint. HarperDB most fascinating only The most notable features of HarperDB are: using a single endpoint execute SQL queries on JSON data it removes the need for an ORM by returning the results as JSON arrays the ability to insert data via JSON, CSV or using SQL Does not that look interesting? Prerequisites Before going further, there are some prerequisites you should be aware of. The tutorial assumes basic knowledge of: Node.js and FastifyJS Databases JavaScript Knowing how to use a package manager like npm Additionally, you should have a Node version of 12.xx or higher for HarperDB to run. Lastly, you need to have a HarperDB account, which you can create . Do not worry; it's ! here free Set up the folder structure The first step of the tutorial is to set up the folder structure of the application. Create a new folder called and open it. You can do it with the following commands: course-management mkdir course-management
cd course-management The basic folder structure is ready. Of course, when you build each part of the application, you'll create more folders. Install dependencies At this point, you should be in the folder. Let's initialise the project with the following command: course-management npm init -y The flag generates the "package.json" automatically without you having to answer the usual questions about the project name, description and so on. If you open "package.json", you can see that all fields are autocompleted. -y Install the required packages The next step is to install the packages needed to build the application. You can install multiple packages in one line. Run the command below in your terminal: npm i fastify harperive dotenv --save The command installs three packages/dependencies: - FastifyJS is a new web framework, and it claims to be the fastest web framework in town. Fastify - It's the Node.js driver for HarperDB. Harperive - A module that loads environment variables from an .env file to process.env. Dotenv Configure the Fastify server Before proceeding to configure the server, you need to create a few files. The first step is to create the following files: touch app.js
touch .env The file contains the server configuration. On the other hand, the file stores your environment variables. Open the file and write the following code: app.js .env app.js app = ( )({ : }); ( ).config()

app.get( , (req, res) => {
    res.send({ : });
});

app.listen(process.env.PORT, (err, addr) => { (err) {
        app.log.error(err);
        process.exit( );
    }

    app.log.info( );
}); const require 'fastify' logger true require 'dotenv' '/' hello 'world' if 1 `Your server is listening on port 🧨` ${process.env.PORT} With the first line, you import the Fastify package and store it in a constant named . In the same line, you also enable the . After that, you import so you can use environment variables. app logger dotenv Lastly, you create a GET route that responds with JSON, and then you listen on the port specified in the file. .env Moving on, open the file and add the following lines: .env PORT= INSTANCE_URL=
INSTANCE_USERNAME=
INSTANCE_PASSWORD=
INSTANCE_SCHEMA= 3000 The fields starting with will hold information about the database. Now, it's time to create a HarperDB account if you do not have one already. INSTANCE Create and configure the database First of all, login into the . After you log in, click on the button, which creates a new HarperDB Cloud Instance. Figure 1 illustrates that! HarperDB Studio + Figure 1 After that, you will be asked to choose either a "New HarperDB Cloud Instance" or "Register User-Installed Instance", as shown in figure 2. Figure 2 Click on the button saying " ". As a result, you create a database instance in their cloud rather than hosting it yourself. After that, you need to enter: Create HarperDB Cloud Instance the name of the instance a username a password In figure 3 below, you can see my instance information. Figure 3 The next step is to choose your . For this tutorial, I advise you to choose the free options. You get the following specs for free: instance specifications 0.5GB RAM 1GB of storage and 100 IOPS Figure 4, below, illustrates that! However, if you plan to use the DB heavily, I recommend powering up the instance and choose better specifications! Figure 4 The last step is to confirm the instance details and then wait for the instance to spin up. After the instance is set up and initialised, click on the instance. For example, you can see my newly-created instance in figure 5 below. If you are accessing the instance for the first time, you might be prompted to enter the username and password you set previously. Figure 5 Your instance does not have any schemas or tables at the moment. As a result, you need to create a schema first! You can see that I chose as the name for my schema (figure 6). However, you can use any other name for your schema. mydb Once you chose a name for your schema, click on the green checkmark to save it! Figure 6 Lastly, you need to create tables. For the moment, you'll set up only one table called . Enter the name "courses" and provide a name as well. The "hash attribute" is used to uniquely identify each record. In simpler words, the "hash attribute" is the ID, which is unique for each record. Now, click on the green checkmark to save it. As shown in figure 7. courses hash_attribute Figure 7 Now, you are ready to use the database in the Node.js application! Set and config HarperDB in the app Go into the .env file and add the following lines: INSTANCE_URL=https: INSTANCE_USERNAME=admin
INSTANCE_PASSWORD=password
INSTANCE_SCHEMA=mydb //app-tutorial.harperdbcloud.com/ Of course, you need to change those details with yours! The above information is fictive, so it will not work if you try! Save the file, and let's move on! Now create two folders and a database file. You can do so by following these commands: mkdir src
mkdir src/db
touch src/db/db_config.js With the above commands, you create the "db" folder inside "src". Also, you create the file "db_config.js" that stores the configuration for the database. Open the newly-created file and write the following code: db_config.js harperive = ( ).Client; DB_CONFIG = { : process.env.INSTANCE_URL, : process.env.INSTANCE_USERNAME, : process.env.INSTANCE_PASSWORD, : process.env.INSTANCE_SCHEMA
}; client = harperive(DB_CONFIG); .exports = client; const require 'harperive' const harperHost username password schema const new module With the first line, you import the Node.js driver for HarperDB. After that, you create the database configuration with the details stored in the file. Lastly, you create a new client and export it. .env You'll use the client later, in the controller file! For now, let's move to the routes and controllers. Configure app endpoints The first step is to create two new folders in the folder. Create them as follows: src mkdir src/controllers
mkdir src/routes After that, you need to create two new JavaScript files in the newly-created folders. Create the files and as follows: course.js courseController.js touch src/routes/course.js
touch src/controllers/courseController.js You'll start by creating the routes. In this scenario, you can make use of the FastifyJS plugin architecture. So open the file from the "routes" folder, and write the following code: course.js courseController = ( ); {

} .exports = routes; const require '../controllers/courseController' async ( ) function routes app, opts module There are three things happening: You import the controllers used for routes. You create a routes function. You export the newly-created routes function. In this method - routes - you configure the endpoints of your application. For each route, you specify the , the and the at minimum. HTTP method URL handler However, there are many other parameters. You can see the complete list here . With that being said, let's build the first endpoint that returns all the courses when accessed. You can do so by calling the method on the , as follows: route app courseController = ( ); { app.route({ : , : , : courseController.getCourses
    });
} .exports = routes; const require '../controllers/courseController' async ( ) function routes app, opts // Get all courses method 'GET' url '/courses' handler module You build all the other routes/endpoints in a similar fashion. The only things that change are the method, URL and handler. In the Gist below, you can see all the endpoints. You have an endpoint for each CRUD operation. Application users can see all the courses, a specific course, add new courses, delete and edit existing courses. courseController = ( ); { app.route({ : , : , : courseController.getCourses
    }); app.route({ : , : , : courseController.getSpecificCourse
    }); app.route({ : , : , : courseController.addCourse
    }); app.route({ : , : , : courseController.editCourse
    }); app.route({ : , : , : courseController.deleteCourse
    });
} .exports = routes; const require '../controllers/courseController' async ( ) function routes app, opts // Get all courses method 'GET' url '/courses' handler // Get a specific course method 'GET' url '/courses/:id' handler // Add a course method 'POST' url '/courses' handler // Edit a course method 'PUT' url '/courses/:id' handler // Delete a course method 'DELETE' url '/courses/:id' handler module : Each route/endpoint has a specific controller, as you can see. At the moment, they are just placeholders because there are no controllers. That means, if you try to access the routes they won't work! But that changes in the next step because you'll build the application logic now. Note Go to the in the root folder, and add the following line: One more thing before going further. app.js app.register( ( )); require './src/routes/course' The purpose of that line is to make the routes available in your application. If you do not add this line, your routes will not work. The final version of should look as follows: app.js app = ( )({ : }); ( ).config()
app.register( ( ));

app.listen(process.env.PORT, (err, addr) => { (err) {
        app.log.error(err);
        process.exit( );
    }

    app.log.info( );
}); const require 'fastify' logger true require 'dotenv' require './src/routes/course' if 1 `Your server is listening on port 🧨` ${process.env.PORT} Build application logic with HarperDB The application logic defines what happens when a user makes a request to the routes specified in the previous section. As an example, when someone accesses the route , they should see all the courses from the database. As a result, let's start with that route. /courses The code for all routes will be in . Thus, open the file and import the "Harperive" client at the top of the file: courseController.js courseController.js client = ( ); const require "../db/db_config" Now, this where the fun begins. To portray the capabilities of HarperDB, you'll use both SQL and NoSQL operations to manipulate data. Build the GET route In the same file, add the following code after importing the database client: getCourses = (req, res) => { allCourses = client.query( );

    res.send({ allCourses });
}; .exports = {
    getCourses,
} const async const await 'SELECT * FROM mydb.courses' module As you can see, the HarperDB Node.js driver allows you to run SQL queries on your database. The above query selects and returns all the courses from the database. After that, you use the object to send the data to the client. If you run the application and try to access the route, you won't get any data because the database is empty. response /courses Figure 8 Figure 8 illustrates a successful request. You can see that the "data" array is empty because the database is empty. However, we'll repeat the request once there is data in the database. Build the POST route The next step is to build the POST route so you can add data into your database. In this case, we'll use a NoSQL operation. Write the following code after the constant: getCourses addCourse = (req, res) => { allProperties = .keys(req.body).length; (allProperties !== ) {
        res.code( ).send({ : }); ;
    } { newCourse = client.insert({ : , : [
                { : req.body.name, : req.body.description, : req.body.author, : req.body.link
                }
            ]
        });

        res.send({ newCourse });
    } (error) {
        res.send({ error });
    }
}; .exports = {
    getCourses,
    addCourse,
} const async const Object if 4 400 error 'Some properties are missing! Add the name, description, author and link!' return try const await table 'courses' records name description author link catch module First of all, the part before the block makes sure the user provides all the fields. If the user tries to add a course without specifying the , , or , it will return an error. The user must always provide all four fields. try catch name description author link Then, in the block, you use the database client to insert the new course into the database. try catch - You need to specify the table (which in this case is ) and then the . courses records - The field is an array of objects, which means you can enter multiple courses in one go. However, for now, one is enough. records Provided the insertion is , it returns the newly-added course. You can see the route in action in figure 9 below. successful Figure 9 The operation was successful, and the new course was added to the database! Figure 10 shows the course in the database! Figure 10 GET a specific course Getting a specific course is similar to getting all courses, but with one addition. Now, you use a clause to select a specific course. WHERE You pass the course "ID" in the URL, and then the SQL query matches that with a record from the database. But first of all, , you might ask! There are two options ( ): how do you get the ID? you need courses in the database first 1. You can visit the route and get the ID of any course you want. http://localhost:3000/courses 2. Go to the HarperDB studio, click on the course, and you'll see all the details. At the top of the page, you'll see that it specifies which one is the ID - see figure 10 above. getSpecificCourse = (req, res) => { course = client.query( );

    res.send({ course });
}; .exports = {
    getCourses,
    addCourse,
    getSpecificCourse,
} const async const await `SELECT * FROM mydb.courses WHERE id=" "` ${req.params.id} module After that, it returns the course. Figure 11 below illustrates what happens when you make a GET request to get a specific course! Figure 11 DELETE a specific course You can delete a course by providing the course ID in the URL. For example, if you make a request to , you delete the course with the specified ID. DELETE http://localhost:3000/courses/0eb95456-255b-44da-b3df-b90671ef0908 deleteCourse = (req, res) => { course = client.query( );

    res.send({ : , : course
     });
}; .exports = {
    getCourses,
    addCourse,
    getSpecificCourse,
    deleteCourse
} const async const await `DELETE FROM mydb.courses WHERE id=" "` ${req.params.id} message 'Course deleted!' deleteCourse module Once the course is deleted, it sends a message confirming that and some more extra information. Figure 12 illustrates a "DELETE" request. Figure 12 Build the PUT route Lastly, this route allows you to update an existing course. All the code before the block makes sure the users only use the allowed fields - , , and . If the user tries to update a field that does not exist, the server will respond with an error. try catch name description author link To edit the course, you're using a NoSQL operation again. You call the method on the database client, then pass the table name and the records you want to update. update (courses - in this case) Also, it's essential to specify the in the records array. If you do not, the server does not know which record to update. id editCourse = (req, res) => { updates = .keys(req.body); allowedUpdates = [ , , , ]; isValidOperation = updates.every( allowedUpdates.includes(update)); (!isValidOperation) {
        res.code( ).send({ : }); ;
    } { updatedCourse = client.update({ : , : [
                { : req.params.id, : req.body.name, : req.body.description, : req.body.author, : req.body.link
                }
            ]
        });

        res.send({ updatedCourse });
    } (error) {
        res.send({ error });
    }
}; .exports = {
    getCourses,
    addCourse,
    getSpecificCourse,
    deleteCourse,
    editCourse
} const async const Object const 'name' 'description' 'author' 'link' const ( ) => update if 400 error 'Not a valid operation! ' return try const await table 'courses' records id name description author link catch module If there is an error, the server sends back the error. Otherwise, it returns the updated course. The figure below shows how to make a PUT requests and what happens it's successful! Figure 13 That's all about routes and controllers! You can see the whole file in . I chose not to embed it because it is big and takes a significant space on the page! courseController.js this Gist Similarly, you can . To learn better, go through it, change stuff, break stuff, add things and so on! see the complete application on my GitHub How to start the application You can start the application by running node in the root folder. app.js However, if you clone the application from GitHub, you need to install the dependencies first. You can do so by running: npm install
node app.js Conclusion By this point, you should have a REST API that allows you to store and manipulate courses. The purpose of this tutorial was to get up-to-speed with the two technologies. As a result, other things could be added, such as: Authorization API rate limiting Adding a front-end and transform it into a full-stack application With that being said, if you like the tutorial and want part 2, where I build the front-end with Vue, let me know in the comments! Previously published at https://catalins.tech/build-a-rest-api-with-harperdb-and-fastifyjs

How to Create a RESTful API With HarperDB and FastifyJS

Many people learn or understand new things relative to things they already know. This makes sense; it’s probably a natural instinct. When it comes to products and technology, a lot of people ask “how are you different,” but different from what? You need some sort of baseline to start from, so you can say, “Similar to X, but different because of Y.” Because of this, comparisons, competitive analysis, and feature matrices are a great way to understand which technology solutions are right for you. So today, let’s do a comparison of three different database systems. The point of this article is not to determine which database is the best but to help uncover the factors to consider when selecting a database for your specific project. In most cases, it’s not that one database is better than the other, it’s that one is a better fit for a specific use case due to numerous factors. With MongoDB and PostgreSQL being two of the most popular tools out there, you may already know that there are tons of resources comparing the two. However, with HarperDB being a net new database, I thought it might be helpful to throw it in the mix to provide further clarity. Referring to my overview post: It’s important to understand things such as data type/structure, data volume, consistency, write & read frequency, hosting, cost, security, and integration constraints. That article provides a great high-level explanation across all different types of databases, but today we’ll get more specific. database architecture Similarities These technologies are all similar in that they are used to store data, but that simple concept is where the similarities end. However, while MongoDB and PostgreSQL are actually quite different from one another, HarperDB lies somewhere in the middle. As mentioned, there are numerous resources out there comparing MongoDB and PostgreSQL, which are both awesome databases. from Educative is one great place to start for understanding the differences between them. Therefore, to avoid redundancy, in this post I will focus a bit more on HarperDB compared to the two. This article Definitions is classified as a NoSQL database. It is document-oriented and uses JSON-like documents with optional schemas. MongoDB is a traditional RDBMS (relational database management system). Mainly used for relational data, it is object-oriented in nature. PostgreSQL is a geo-distributed database with a REST API and dynamic schema, that supports NoSQL and SQL including joins. (For example, you can ingest data via NoSQL JSON then immediately query it via SQL) HarperDB Differences Overview : PostgreSQL is a relational database handling more complex procedures, designs, and integrations. MongoDB is a NoSQL database often used for simpler, more unstructured data, great for app development. Ultimately, PostgreSQL enforces schema validations whereas Mongo does not. MongoDB vs. PostgreSQL : MongoDB is a document store that is great for unstructured data, whereas HarperDB offers full document store capability plus enterprise-grade ACID SQL. Benchmark tests found that HarperDB is 37 times faster than MongoDB at less than half the price. HarperDB also has a native REST API, supports SQL on JSON, and can be easier to use and manage. See the . HarperDB vs. MongoDB full benchmark here (Mongo is optimized for high scale writes, but not for reads. HarperDB's data storage algorithm written on top of LMDB enables both high scale reads and writes, resulting in high performance overall.) : HarperDB is more flexible than PostgreSQL, which is a great technology for complicated data or strict consistency, but HarperDB has simplified much of the work on the installation, configuration, and administration. HarperDB is allowing developers from relational backgrounds to use their existing knowledge with SQL with a database that also allows their team to use NoSQL from the same data model. HarperDB v. PostgreSQL Accessibility MongoDB, PostgreSQL, and HarperDB can each run anywhere; in the cloud, locally, data center, etc. (There is not a PostgreSQL cloud like there is with HarperDB Cloud and MongoDB Atlas, but some cloud providers offer PostgreSQL-as-a-service.) Under the hood MongoDB is mainly programmed in C, C++, and JavaScript language. PostgreSQL is mainly programmed in C. HarperDB is (LMDB is written in C, and Python is used in the install process). written in Node.js MongoDB uses BSON (binary JavaScript Object Notation) under the hood to make querying fast. This is then translated to JSON to be read when you open your collection. PostgreSQL ultimately employs SQL, a structured query language, to define, access, and manipulate the database. PostgreSQL also has a JSON datatype. HarperDB does not enforce data types; it currently stores all data attributes as strings, and data can be queried via SQL and/or NoSQL. (HarperDB is also working on enabling the ability for administrators to explicitly set attribute types (as numbers or strings) for performance tuning). Data Storage & Architecture MongoDB stores data as individual documents without regard to attributes, PostgreSQL stores data in traditional tables and rows, and HarperDB stores data in tables and rows/objects with all top-level attributes indexed by default. HarperDB has a unique data storage algorithm running on top of LMDB, this enables HarperDB to ingest JSON documents and relational data in a single product. As data comes in, HarperDB maps it to the data model; it's not a SQL engine or a NoSQL engine. Regardless of how data is ingested, data is stored according to the HarperDB data model and can be queried via SQL or NoSQL. MongoDB and HarperDB are more distributed architectures, whereas PostgreSQL might be considered a monolithic architecture. ACID Properties (atomic, consistent, isolated, & durable) HarperDB and PostgreSQL both have enterprise-grade ACID SQL transactions, meaning the validity of data is quite reliable. NoSQL databases like MongoDB usually adopt eventual consistency instead of ACID properties. (A study from May 2020 identified a bug that disputes claims that Mongo is ACID compliant, as MongoDB’s transactions are not fully isolated). HarperDB and PostgreSQL both follow the ANSI SQL standard. Schema & Tables With both MongoDB and HarperDB, using JSON allows you to change your schema flexibly without consequence. Documents can vary in terms of key/value pairs. Both MongoDB and HarperDB scale horizontally, which allows for speed. HarperDB has bidirectional table-level data replication. HarperDB uses a simple pub-sub model; data is replicated by publishing data to different “chat rooms” which different nodes subscribe to and are able to be distributed horizontally. PostgreSQL scales vertically (as it gets bigger, more space or more memory is needed), therefore it requires downtime to upgrade. With relational databases like PostgreSQL, altering your table is necessary to make any changes. The whole schema needs to be designed and configured at creation. You might be able to alter a table later on, but this may lead to database downtime and bugs in your application. PostgreSQL databases can use foreign keys which explicitly link data between tables and are used to keep the data normalized. Use Cases & Summary As stated in , because transactions in PostgreSQL follow ACID properties, it’s a good choice for industries such as fintech. When you absolutely need to control the state of your data, use a relational database like Postgres. Alternatively, if you only have unstructured data, or are working with big data, it might be a good idea to use the horizontal scaling approach with a tool like MongoDB. this article Use cases where HarperDB might be a better fit than existing systems include projects where you need SQL and NoSQL, rapid application development, hybrid cloud, integration, edge computing, and distributed computing. Our team will also be the first to tell you when HarperDB is not a good fit for your specific project. HarperDB is not recommended when you need full-text indexing, highly structured relational data, or strict consistency across systems. Both MongoDB and PostgreSQL are really great tools for certain use cases. They are loved by many and the team at HarperDB is thankful that they have paved the way for technologies like ours to exist. HarperDB was created to expand and blend the capabilities of awesome SQL, NoSQL, and products on the market to fill in the gaps and ensure that developers are continuously empowered to use the right tool for the job. NewSQL Sources https://www.educative.io/blog/mongodb-versus-postgresql-databases https://harperdb.io/ https://en.wikipedia.org/wiki/MongoDB https://en.wikipedia.org/wiki/PostgreSQL https://www.techshout.com/software/2020/19/mongodb-vs-postgresql-what-are-the-similarities-and-differences/ Also published at https://dev.to/harperdb/harperdb-vs-mongodb-vs-postgresql-49en

Which Database Is Right For You? HarperDB vs. MongoDB vs. PostgreSQL

Suppose you are searching for information on a website. Let’s imagine a Twitter user writes about CRYPTOCURRENCY! What do you do? You can copy and paste the tweets about CRYPTOCURRENCY into your own file. But what if you want to retrieve massive volumes of information from Twitter? Such as vast quantities of information for your data science project? In this circumstance, copying and pasting won’t work! Then you will need to utilize Web Scraping. What is Web Scraping? The term “web scraping” refers to an automated process that can collect significant volumes of data from websites. The majority of this data is unstructured data that is stored in an HTML format. In order for this data to be utilized in a variety of applications, it must first be converted into structured data that is stored in a spreadsheet or a database. For many businesses, web scraping can be used to quickly and inexpensively gather data that can then be analyzed in a variety of ways such as news monitoring, sentiment analysis, email marketing, and others. Web scraping, the process of obtaining data from websites through automated means, can be carried out in a variety of different methods. Application Programming Interfaces (APIs) e.g from Twitter, StackOverflow & Google. Write code (e.g in the Python programming language). Online services from different providers e.g Octoparse. In this article, you will learn how to: How to execute web scraping on Twitter using the Python library. snsscrape How to store scraped data automatically in the database using . HarperDB How to share your data via API call by using Custom Function from . HarperDB So let’s get started. What is Snscrape? snscrape is a scraping tool for social networking services (SNS). It scrapes information like user profiles, hashtags, searches, and threads and returns the discovered items, e.g. the relevant posts. It was released on July 8, 2020, and it is capable of scraping data from a variety of platforms, including the following: Twitter Instagram Reddit Facebook Weibo Telegram Mastodon You can use snscrape by typing its command-line interface (CLI) commands into the command prompt/terminal. If you don’t feel comfortable using a terminal, you can use snscrape as a , but this is not yet documented. Python library On Twitter, it can scrape users, user profiles, hashtags, searches, tweets (single or surrounding thread), list posts, and trends. Note: What is HarperDB? is a lightning-fast and versatile platform for managing SQL and NoSQL data. You can put it to work for a wide variety of purposes, some of which include but are not limited to quick application development, distributed computing, edge computing, software as a service (SaaS), and many others. HarperDB HarperDB does not duplicate data, is fully indexed and can run on any device, from the edge to the cloud. Additionally, it may be used with any programming language, such as Javascript, Java, , and others. Python The following is a list of a few of the features that can be accessed with HarperDB: Allows JSON and CSV file insertions. Single endpoint API. Supports SQL queries for full CRUD operations. (Lambda-like application development platform with direct access to HarperDB’s core methods). Custom Functions Limited database configuration required. Math.js and GeoJSON are both supported. HarperDB has a built-in HTTP API, custom functions for user-defined endpoints, and a dynamic schema that can help you easily share your scraped data with your coworkers after storing them in a HarperDB cloud instance. HarperDB allows you to quickly download scraped data held in the HarperDB instance as a CSV file so that you can perform extra analysis before making a final choice. After being introduced to the tools (snscrape & harperDB) that you will use to automate the process of scraping data and saving it in the database. Then all you have to do is follow the steps that are described below Step 1: Create a HarperDB Account We will start by working on the HarperDB database first. You can visit and then click the navigation bar to see a link called “Start Free.” Click it in order to create your account. https://harperdb.io/ If you already have an account, use the following URL to sign in with your credentials. https://studio.harperdb.io/ Step 2: Create a HarperDB Cloud Instance After registration, you need to create a cloud instance to store and fetch your scraped data from Twitter. Click the Create New HarperDB Cloud Instance link to add a new instance to your account. You just need to follow all instructions provided by harperDB to create your cloud instance, such as: Note: Select Instance Types.Choose Cloud Provider. Add instance information. Select instance specification (RAM size, instance storage size, and instance region). Confirm and create a cloud instance. When the HarperDB Cloud Instance has been created successfully, you will see the status as OK for that particular instance, check the image below. Step 3: Configure the HarperDB Schema and Table To add the Twitter data that has been scraped into the database, you must first create a schema and a table. It only requires loading the HarperDB cloud instance you already created from the dashboard and creating the schema by giving it a name (like “data_scraping”). You then have to add a table (e.g ). Additionally, HarperDB will ask you to specify the hash attribute, which is equivalent to an ID number. “tweets” Step 4: Install the Required Packages You need to install the following package on your local machine. This is the we’ll use to implement different HarperDB API functions sucha as inserting data into to the cloud instance. It also provides wrappers for an object-oriented interface. (a) harper-sdk-python Python package pip install harperdb Snscrape requires Python 3.8 or higher. When you install snscrape, the dependencies for the Python package are automatically installed. (b) snscrape pin install snscrape Step 5:Import Important Packages The next step is to import Python packages to scrape data from Twitter and automatically store them on harperDB cloud instance. #import packages #snscrape import snscrape.modules.twitter as sntwitter # harperdb import harperdb import warnings # To ignore any warnings warnings.filterwarnings( "ignore" ) Step 6: Connect to HarperDB Cloud Instance You need to connect to the HarperDB cloud instance in order to insert scraped tweets into the table called . tweets Here you need to provide three parameters: Full URL of the HarperDB instance Your username Your password db = harperdb.HarperDB(url=URL, username=USERNAME, password=PASSWORD) db.describe_all() # connect to harperdb URL = "https://1-mlproject.harperdbcloud.com" USERNAME = "USERNAME" PASSWORD = "PASSWORD" # check if you are connected When you execute the above code, you will see output similar to that displayed below, indicating a successful connection to your HarperDB Cloud Instance. '__updatedtime__': 1660390877630,
   'hash_attribute': 'id',
   'id': 'd140645e-3af2-42d7-8594-2195826dabbc',
   'name': 'tweets',
   'residence': None,
   'schema': 'data_scraping',
   'attributes': [{'attribute': '__createdtime__'},
    {'attribute': '__updatedtime__'},
    {'attribute': 'id'}],
   'record_count': 0}}} {'data_scraping': {'tweets': {'__createdtime__': 1660390877630, Step 7:Create a Function to Record the Scrapped Tweets Using the from the harperdb-python package, the following function will insert the scraped tweets as data (in dictionary format) into the specified table.The insert function will receive three parameters: insert function SCHEMA name TABLE name data (scraped tweets) result = db.insert(SCHEMA, TABLE, [data]) # define a function to record scraped data into the table def record_tweets ( data ): #define the schema and table SCHEMA = "data_scraping" TABLE = "tweets" # insert data into the table return result Step 8:Scrape tweets by using snsscrape Now you can use T from snsscrape python package to scrap tweets with the particular search query. In this example, I will show you how to scrap 1,000 tweets about “ from 1st January 2022 to 13th August 2022. witterSearchScrapper method cryptocurrency” sntwitter.TwitterSearchScraper( data = { } result = record_tweets(data) #1 Using TwitterSearchScraper to scrape data and append tweets to list for i, tweet in enumerate ( 'crytocurrency since:2022-01-01 until:2022-08-13' ).get_items()): if i > 1000 : break #2 save data automatically to the HarperB cloud instance "user_name" : tweet.user.username, "content" : tweet.content, "lang" : tweet.lang, "url" : tweet.url, "source" : tweet.source # insert result into the HarperDB table As you can see from the code block above , harperDB will automatically store scraped data into the tweets table with the following attributes. (comment #2) Username Content Lang Url Source Step 10:View the Tweets Table If you open your HarperDB cloud instance, you will be able to see all records of your scraped data from Twitter. 🎉 You have successfully completed all required steps to automate the process of scraping data and saving it in the database. Congratulations What if you wish to share the scraped information with your colleagues? Custom Function provides a straightforward solution to this problem in HarperDB. What is a Custom Function? A Custom Function is a brand-new feature included in HarperDB’s 3.1+ release. You can use the feature to add your own to HarperDB. Custom functions are powered by Fastify, which is incredibly flexible and makes it simple to interact with your data by using HarperDB core methods. API endpoints You will learn how to use the HarperDB studio to create your very own custom function in this section. You can then use an API call to share the outcomes of your scraped data with your coworkers at the office. Here are the steps you need to follow:- The first step is to enable the Custom functions by clicking “ ” in your HarperDB Studio (it is not enabled by default). 1. Enable Custom Functions functions The next step is to create a project by specifying the name. For example It will also create setting files for the project including: 2. Create a Project tweets-api-v1. Routes folder File to add helper functions Static folder For this article, you will focus on the routes folder. Note: In this step, you will create the first route to fetch some data from the tweets table from the HarperDB Datastore. You also need to know that Route URLs are resolved in the following manner: 3. Define a Route [Instance URL]:[Custom Functions Port]/[Project Name]/[Route URL] It will include: Cloud Instance URL Custom Functions Port Project name you have created The route you have defined In the route file (example.js) from the function page, you will see some template code as an example. You need to replace that code with the following code: server.route({ request.body= { }; }
}); 'use strict' ; module .exports = async (server, { hdbCore, logger }) => { url : '/' , method : 'GET' , handler : ( request ) => { operation : 'sql' , sql : 'SELECT user_name,content,lang,url,source FROM data_scraping.tweets ORDER BY __createdtime__' return hdbCore.requestWithoutAuthentication(request); In the code above, the route is defined with the GET method and the handler function will send an SQL query to the database to get from the ordered by the /tweets-api-v1 user_name, content, lang, URL, and source tweets table __createdtime__ column. Finally, you can now use the route you have defined to get the data from the tweets table. Here you will send an API request by using the Python package. 4. Access data via API Endpoint requests r = requests.get(url = URL) data = r.json() #send an API request import requests # api-endpoint URL = "https://functions-1-mlproject.harperdbcloud.com/tweets-api-v1" # sending get request and saving the response as response object # extracting data in json format for experiment in data: print (experiment) Here is the sample output from the above code. {"user_name": "DailyCryptoTrad","content": "DXY forming a bullish bull flag on the daily - a break out of 106.6 will give crypto red days however if we fail below 105 will give crypto green days - Keep an eye on DXY #DXY #SPY #crypto #btc #eth #bitcoin #crytocurrency #cryptocurrencies https://t.co/AkF8Igf3Uc","lang": "en","url": "https://twitter.com/DailyCryptoTrad/status/1558211511461597188","source": "<a href=\"https://mobile.twitter.com\" rel=\"nofollow\">Twitter Web App</a>"},{"user_name": "Ariscrypto1970","content": "@scrypto_1977 @Epayme_uae #Saitama will go parabolic when it happens! This is the #WeAreSaitama and the world are waiting for. 🔥🔥🔥🚀🚀🚀🚀#crytocurrency #DeFi","lang": "en","url": "https://twitter.com/Ariscrypto1970/status/1558200674273345537","source": "<a href=\"http://twitter.com/download/iphone\" rel=\"nofollow\">Twitter for iPhone</a>"},{"user_name": "dan_nyeche","content": "Cryptocurrency market up 24Hrs. #Bitcoin #Dan_Trades #crytocurrency Emilokan Big Brother Modella FireBoy Giddyfia  GTBank President Obama #gayfish Gen Z Ethereum Chi Chi Obidatti2023 Sapa Lewandoski #HAPPYJAEMINDAY #Jalsa4K #GomoraMzanzi #SheggzOlu𓃵 #ViratKohli𓃵 https://t.co/QbU4ei3MGA","lang": "in","url": "https://twitter.com/dan_nyeche/status/1558188248362467329","source": "<a href=\"http://twitter.com/download/android\" rel=\"nofollow\">Twitter for Android</a>"}, With HarperDB, you can quickly and easily build API endpoints to share the scraped data with your team working on the same data science project. Note: Conclusion Congratulations 🎉, you have made it to the end of this article. You have learned: How to execute web scraping on Twitter using the Python library. snsscrape How to store scraped data automatically in the database using . HarperDB cloud instance How to create a from the HarperDB cloud instance to share your scraped data with your coworkers working on the project via an API endpoint. custom function If you learned something new or enjoyed reading this article, please share it so that others can see it. Until then, see you in the next post! You can also find me on Twitter @Davis_McDavid.

How to Web Scrape Using Python, Snscrape & HarperDB

Adding authorization & authentication to an app is a common task for developers. When you're launching a new product, a startup, or a side project, it can feel like a mission. This tutorial will teach us how to make a music player app that uses SuperTokens for authentication and HarperDB for the backend. Some of the app's most essential features On Backend Side: Secure your API with almost significantly fewer and zero configurations. Secure your third-party API on the server side using SuperTokens. Session management is simple. On the Front-end side: For login, use SuperTokens' library component, which is available as an npm package. There's no need to develop any extra code for authentication. There's no need to maintain tokens on the UI side. You won't have to worry about managing token refresh calls on the UI side because SuperTokens will take care of it for you. TL;DR Here are the links to get to the source code or learn more about both products faster Source Code SuperTokens SuperTokens GitHub HarperDB What you'll discover How to add authentication using SuperTokens. How to secure 3rd party (HarperDB) endpoints. Let's talk about SuperTokens SuperTokens is an open-source authentication. They help you launch quickly so that you can focus on your core product offering. SuperTokens is 100% open source. Developers can own and manage their user's data. SuperTokens can be run on your premise for free and also has a generously hosted tier for those who don't want to manage it themselves. SuperTokens is a versatile authentication and authorization solution for your applications. Prerequisites This tutorial assumes the reader has the following: Node installed on their local development machine. You can verify if you do by running the command below in your terminal. node -v If otherwise, download from here A basic knowledge of HTML, CSS, JavaScript, and React Take a peek at how we developed our React app and used SuperTokens to authenticate it. A summary of the project's setup Yay! This section will create a React music player app and incorporate SuperTokens and HarperDB. Alternatively, you can utilize the start directory as your project root by cloning the . It includes the whole project setup that will get you started. GitHub repository How to Begin Using SuperTokens SuperTokens provides a variety of ready-to-use recipes from which to choose. You can see all the recipes. here We'll use the pre-built Recipe to access the , which will look something like this. ⬇ EmailPassword demo app The supertokens website has the documentation for this recipe. Click here Now, fork the GitHub repository Let's have a look at all of the project dependencies that were used to make this app Dependencies used:

"dependencies": {
        "axios": "^0.21.0",
        "body-parser": "^1.19.0",
        "cors": "^2.8.5",
        "express": "^4.17.1",
        "helmet": "^4.6.0",
        "morgan": "^1.10.0",
        "mysql": "^2.18.1",
        "npm-run-all": "^4.1.5",
        "react": "^17.0.1",
        "react-dom": "^17.0.1",
        "react-router-dom": "^5.2.0",
        "react-scripts": "4.0.0",
        "supertokens-auth-react": "^0.17.0",
        "supertokens-node": "^8.0.0",
        "web-vitals": "^0.2.4"
    },
    "devDependencies": {
        "@testing-library/jest-dom": "^5.12.0",
        "@testing-library/react": "^11.1.0",
        "@testing-library/user-event": "^12.6.2",
        "nodemon": "^2.0.12"
    }, Using the SuperTokens npm package in a React application The following use cases are demonstrated in this demo app. Login Sign up Logout Forgot password flow Session management & Calling APIs You can now install the project dependencies with npm: npm install Now it's time to put this demo app to work. npm run dev The example app will run on ( ), while the API server will run on ( ). http://localhost:3000 http://localhost:3001 On the frontend, authentication We use the supertokens-auth-react package on the front end to handle authentication (sending and receiving tokens). The Session is initialized in the app.js file: SuperTokens.init({
    appInfo: {
        appName: "Music Player", // TODO: Your app name
        apiDomain: getApiDomain(), // TODO: Change to your app's API domain
        websiteDomain: getWebsiteDomain(), // TODO: Change to your app's website domain
    },
    recipeList: [
        EmailPassword.init({
            emailVerificationFeature: {
                mode: "REQUIRED",
            },
        }),
        Session.init(),
    ],
}); To deliver the token to the server in an API request, we must include the following line. Session.addAxiosInterceptors(axios); The Supertokens-auth-react package will handle storing tokens on the client, transmitting tokens to the server, and updating tokens before they expire. Let's discuss the react component that we used to create the music player app In Visual Studio Code, the folder structure appears like this: 1- Music Container (MusicContainer.jsx) We manage all of the state-related stuff in this component and render all of the child components. Here, we call the songs endpoint exposed by API server.js to get the list of songs. import React, { useCallback, useState } from "react";
import SongList from "./SongList.jsx/SongList";
import Player from "./Player/Player";
import SongDetail from "./SongDetails/SongDetails";
import axios from "axios";
import { getApiDomain } from "../utils/utils";
import useAsync from "../Hooks/useAsync";

export default function MusicContainer() {
    const asyncCallback = useCallback(() => {
        return axios.get(`${getApiDomain()}/songs`);
    }, []);
    const { data } = useAsync(asyncCallback);
    const songs = data || [];
    const [selectedSong, setSelectedSong] = useState(0);

    return (
        <>
            <SongDetail selectedSongId={selectedSong} songs={songs} />
            <SongList selectedSong={selectedSong} songs={songs} selectedSongId={(id) => setSelectedSong(id)} />
            {songs.length > 0 && (
                <Player songs={songs} selectedSongId={selectedSong} selectSongById={(id) => setSelectedSong(id)} />
            )}
        </>
    );
} 2- Song List (SongList.jsx) All of the songs are rendered in this component. And the player component will play each of the songs in the panel when you click on them in the panel. import React from 'react'
import './SongList.css'
import logo from '../../playing.gif'

export default function SongList({songs, selectedSongId, selectedSong}) {
  return (
    <>
      <div className="header">
        <div className="track-number">#</div>
        <div className="track-title">Title</div>
        <div className="track-author">Author</div>
      </div>

      <div className="song-main">
        {' '}
        {songs.map((item, index) => (
          <div
            key={index}
            className={`song-list ${index === selectedSong ? 'active' : ''}`}
            onClick={() => selectedSongId(index)}
          >
            {index !== selectedSong ? (
              <div className="track-number">{index + 1}</div>
            ) : (
              <div className="index">
                <img alt="" src={logo} id="focused" className="small-icon" />
              </div>
            )}
            <div className="track-title">{item.name}</div>
            <div className="track-author">{item.author}</div>
          </div>
        ))}
      </div>
    </>
  )
} 3. Player (Player.jsx) The HTML5 audio element is used in this player component to play all of the songs in the app. import "./Player.css";
import { useCallback, useEffect, useRef, useState } from "react";
import { forwardsSvg, backwardsSvg, shuffleSvg } from "../svg";
import Progress from "../ProgressBar/ProgressBar";
import SongTime from "./SongTime";

export default function Player({ selectedSongId, songs, selectSongById }) {
    const [shuffled, setShuffled] = useState(false);
    const [currentTime, setCurrenTime] = useState(0);
    const [duration, setDuration] = useState(0);
    const [currentVolume, setCurrentVolume] = useState(100);
    const [playerState, setPlayerState] = useState(false);
    const audioRef = useRef();
    let intervalRef = useRef();
    let clicked = useRef(false);

    const spaceDownFunc = useCallback((event) => {
        if (event.keyCode === 32 && !clicked.current) {
            clicked.current = true;
            document.getElementsByClassName("main-control")[0].click();
        }
    }, []);
    const spaceUpFunc = useCallback((event) => {
        if (event.keyCode === 32 && clicked.current) {
            clicked.current = false;
        }
    }, []);

    useEffect(() => {
        document.addEventListener("keydown", spaceDownFunc);
        document.addEventListener("keyup", spaceUpFunc);
        return () => {
            clearInterval(intervalRef.current);
            document.removeEventListener("keydown", spaceDownFunc);
            document.removeEventListener("keyup", spaceUpFunc);
        };
    }, [spaceDownFunc, spaceUpFunc]);

    if (selectedSongId < 0 || selectedSongId > songs.length - 1) {
        selectSongById(0);
    }

    useEffect(() => {
        if (audioRef.current) {
            audioRef.current.volume = currentVolume / 500;
        }
    }, [currentVolume]);

    const onMusicPlay = (e) => {
        e.preventDefault();
        setPlayerState((prev) => !prev);
    };

    const onBackwardClick = () => {
        if (selectedSongId > 0) {
            selectSongById(selectedSongId - 1);
        }
    };
    const onForwardClick = () => {
        if (selectedSongId < songs.length - 1) {
            selectSongById(selectedSongId + 1);
        }
    };

    useEffect(() => {
        setPlayerState(true);
    }, [selectedSongId]);

    useEffect(() => {
        if (playerState) {
            audioRef.current.play();
        } else {
            audioRef.current.pause();
        }
    }, [playerState, selectedSongId]);

    return (
        <div id="player">
            <SongTime currentLocation={currentTime} duration={duration} />
            <div
                className="control"
                id={shuffled ? `active` : null}
                onClick={() => {
                    setShuffled(!shuffled);
                }}>
                {shuffleSvg}
            </div>
            <div className="control" onClick={onBackwardClick}>
                {backwardsSvg}
            </div>
            <div className="main-control control" onClick={onMusicPlay}>
                <i className={`fas fa-${playerState ? "pause" : "play"}-circle`}></i>
            </div>
            <div className="control" onClick={onForwardClick}>
                {forwardsSvg}
            </div>
            <Progress value={currentVolume} setVolume={(vol) => setCurrentVolume(vol)} />

            <audio
                id="main-track"
                controls
                src={songs[selectedSongId].url}
                preload="true"
                onEnded={() => {
                    selectSongById(shuffled ? Math.round(Math.random() * songs.length) : selectedSongId + 1);
                }}
                onLoadedMetadata={() => {
                    setDuration(audioRef.current.duration);
                    intervalRef.current = setInterval(() => {
                        if (audioRef.current) {
                            setCurrenTime(audioRef.current.currentTime);
                        } else {
                            clearInterval(intervalRef.current);
                        }
                    }, 1000);
                }}
                ref={audioRef}
                hidden>
                Your browser does not support the
                <code>audio</code> element.
            </audio>
        </div>
    );
} 4- Progress (Progress.jsx) The progress bar component is used to show the song's progress. import React from "react";
import "./ProgressBar.css";

export default class ProgressBar extends React.Component {
    constructor(props) {
        super(props);
        this.state = { showTooltip: false };
    }
    render() {
        return (
            <div className="progress">
                <input
                    type="range"
                    min="0"
                    max="100"
                    className="slider"
                    value={this.props.volume}
                    onChange={(e) => this.props.setVolume(e.target.value)}
                    onMouseEnter={() => this.setState({ showTooltip: true })}
                    onMouseLeave={() => this.setState({ showTooltip: false })}
                />
                {this.state.showTooltip && <span className="tooltip">{this.props.volume}</span>}
            </div>
        );
    }
} 5- Song Detail (SongDetail.jsx) The track title and album thumbnail image are displayed in this component. import React from 'react'
import './SongList.css'
import logo from '../../playing.gif'

export default function SongList({songs, selectedSongId, selectedSong}) {
  return (
    <>
      <div className="header">
        <div className="track-number">#</div>
        <div className="track-title">Title</div>
        <div className="track-author">Author</div>
      </div>

      <div className="song-main">
        {' '}
        {songs.map((item, index) => (
          <div
            key={index}
            className={`song-list ${index === selectedSong ? 'active' : ''}`}
            onClick={() => selectedSongId(index)}
          >
            {index !== selectedSong ? (
              <div className="track-number">{index + 1}</div>
            ) : (
              <div className="index">
                <img alt="" src={logo} id="focused" className="small-icon" />
              </div>
            )}
            <div className="track-title">{item.name}</div>
            <div className="track-author">{item.author}</div>
          </div>
        ))}
      </div>
    </>
  )
} Securing 3rd party APIs We're using an API server to use the Super tokens backend package for token management and session management. let supertokens = require("supertokens-node");
let Session = require("supertokens-node/recipe/session"); The supertokens node package must first be initialized: supertokens.init({
    framework: "express",
    supertokens: {
        // TODO: This is a core hosted for demo purposes. You can use this, but make sure to change it to your core instance URI eventually.
        connectionURI: "https://try.supertokens.io",
        apiKey: "<REQUIRED FOR MANAGED SERVICE, ELSE YOU CAN REMOVE THIS FIELD>",
    },
    appInfo: {
        appName: "SuperTokens Demo App", // TODO: Your app name
        apiDomain, // TODO: Change to your app's API domain
        websiteDomain, // TODO: Change to your app's website domain
    },
    recipeList: [EmailPassword.init(
        {
                override: {
                apis: (originalImplementation) => {
                    return {
                        ...originalImplementation,

                        signInPOST: async ({formFields, options}) => {
                                     let email = formFields.filter((f) => f.id === "email")[0].value;
                            let password = formFields.filter((f) => f.id === "password")[0].value;
                       
                           
                            // const res = await query(`select * from user where email='${email}'`)
                            if(userId[email]) {
                            let sessionHandles = await Session.getAllSessionHandlesForUser(userId[email]);
                            if(sessionHandles.length > 0) {
                                return {
                                    status: 'SESSION_ALREADY_EXISTS'
                                }
                            }
                        }
                            let response = await options.recipeImplementation.signIn({ email, password });
                            if (response.status === "WRONG_CREDENTIALS_ERROR") {
                                return response;
                            }
                            let user = response.user;
                            userId[email] = user.id;

                            await Session.createNewSession(options.res, user.id, {}, {});
                            // query(`insert into user (email, status) values ('${email}', 'ACTIVE')`)
                            return {
                                status: "OK",
                                user,
                            };
                        },
                       
                    }
                },
            }
    }
    ), Session.init(),
       
    ],
}); We exposed the Song endpoint to the react app to retrieve the music list. We're calling the HarperDB endpoint in this endpoint to receive a list of songs from DB. app.get("/songs", verifySession(), async (req, res) => {
    const resp = await axios.get('https://functions-custom-tyagi.harperdbcloud.com/ToDoApi/songs');
    res.send(resp.data);
}); As a result, the get method's second parameter, verifySession, does the validation(token, Session) for us. The super tokens make this method available. SuperTokens takes charge of token creation and session management when the user logs into the demo app. That was it for this blog. Today, I hope you learned something new, and if you did, please like and share it so that others can see it as well. Thank you for being a regular reader; you're a significant reason I've been able to share my life/work experiences with you. For the most up-to-date information, follow on Twitter. SuperTokens Follow me on Twitter at . TheAnkurTyagi If you want to understand more about SuperTokens, I recommend reading last year's blog article. ⬇ Everything about super tokens - an open-source alternative to Auth0, Firebase Auth, and AWS Cognito. First Published here

Implement Authentication & Security Using SuperTokens in Your React and HarperDB App

Introducing the newest innovation from HarperDB: . With the release of HarperDB 3.1, users are able to define their own API endpoints within HarperDB. What does that mean for you? . We’re collapsing the stack! HarperDB Custom Functions HarperDB grows from a distributed database to a distributed application development platform with integrated persistence - one that can serve as a single solution for all of your backend needs Alright, alright, what’s the big deal? Up until 3.1, in order to power an application, you would need to deploy and host your backend API code on additional servers, then have them call out to HarperDB for database needs. This is a pretty typical software stack, but at HarperDB, we’re far from typical. We’re constantly innovating and changing the game. Oh yeah, and it’s faster, significantly faster! Traditional architectures naturally introduce latency as data moves across multiple servers through a local network or potentially even the Internet. HarperDB is collapsing the stack onto a single server, which eliminates any and all network latency. Custom Functions enable developers to build their entire application backend in one place. This frees up headroom for achieving higher throughput from a single server. Capitalizing on HarperDB’s already powerful horizontal scalability means you can now distribute your APIs and your database to the edge. both For those familiar with modern cloud architectures, Custom Functions are just like AWS Lambda functions. For those familiar with relational databases, they’re like Stored Procedures. You define your logic and choose when to execute it. At a high level, it’s as simple as that! They’re low maintenance and easy to develop. You can develop HarperDB Custom Functions in the Studio or in your own IDE and Version Management System. HarperDB Custom Functions can be maintained like any other development project; in fact, the sample Custom Functions provided in the Studio are generated from our public GitHub repository. That means you can develop, maintain, and deploy your HarperDB Custom Functions code just like any other development project, so you don’t have to deviate from your existing development practices. That’s great news! HarperDB Studio Functions Editor What makes Custom Functions so powerful? They leverage the full power of and . HarperDB Custom Functions projects are effectively just Node.js projects, which means you can leverage the npm ecosystem, opening the doors to fast and efficient development. Node.js Fastify Fastify serves as the basis for the webserver, which means you can define and build a fully functional REST API with all the bells and whistles you’d expect. The key differentiator is that these Fastify routes have direct access to HarperDB core methods, bypassing the HarperDB API and, instead, interacting directly with HarperDB on the same machine. WebStorm IDE with HarperDB Functions Project By collapsing the stack, we deliver unparalleled performance and efficiency out of the box. Let’s take a look at some different ways Custom Functions can be used. I’m not going to cover everything here; in fact, I’m sure there are plenty of options that I haven’t even thought of. : Seamlessly connect third-party/external data with data stored in HarperDB within a single function. Integrate with third-party apps and APIs : Tightly integrate with third-party application providers to validate user requests within your API. Utilize third-party authentication : HarperDB is always adding features, but let’s say there’s a feature you need that’s missing. Build a HarperDB Custom Function to solve the problem. For example, if you need to enforce row-level security based on a user account, write a function! Define your own database functionality : Custom Functions can serve static content and serve as backend APIs, which means you can fully power a website or web app all with HarperDB. Serve a website These are just some of the ideas we’re kicking around with HarperDB Custom Functions. Since this will be the initial release of HarperDB Custom Functions, please let us know what else you’d like to see in future releases. You can submit your ideas to our feedback board here: . feedback.harperdb.io Also Published On: https://lzomedia.com/blog/harperdb-is-collapsing-the-stack-introducing-custom-functions/

HarperDB: Build Your Application Backend in One Place with Custom Functions

I recently had a fascinating conversation with Ron Lewis, the Director of Innovation and Engineering at Lumen Technologies. Ron brought up the notion that HarperDB is more than just a database, and for certain users or projects, HarperDB is not serving as a database at all. How can this be possible? on our podcast Database, Explained Well, what really is a database? states that “In computing, a database is an organized collection of data stored and accessed electronically from a computer system.” states that “​​A database is a systematic collection of data. They support electronic storage and manipulation of data. Databases make data management easy.” Wikipedia Another site So at its core, yes, is certainly a database and can fulfill this functionality (after all, that’s what the DB stands for). But it can do so much more. For example, there are many cases where organizations keep their existing database system(s) in place and use HarperDB to extend their current functionality or for a different capability altogether. HarperDB Especially when it comes to solving complex enterprise data management challenges, the answer rarely (if ever) comes down to this database vs. that database. There’s much more to it. There are many different moving parts related to capturing the right data, getting data to where it needs to be in a timely manner, analyzing and acting on that data, etc. This is really where HarperDB shines. HarperDB: A Runway for Launching Industry 4.0 Technology Ron mentioned in our podcast discussion: “The reason I see HarperDB as a disruptive technology is because you often call HarperDB a database, but it’s not really a database. It’s maybe what some people call a data mesh or data fabric... I see HarperDB more as a data surface, especially with Functions. The whole idea is to be able to converge and contextualize data to support decision making.” The new Ron refers to will enable users to define their own API endpoints within HarperDB, ultimately expanding HarperDB from a distributed database to a distributed application development platform with integrated persistence. Custom Functions So, now we’re thinking of HarperDB as a data mesh, fabric, or surface instead of a database. That’s a lot of buzzwords! Let’s take a step back. When I asked Ron what initially drew him and his team to HarperDB, he provided some great insight. Ron mentioned that they were working on a project for the Department of Defense (DoD) that required moving, contextualizing, and converging data and they needed something super fast and intuitive. They were essentially looking for something easy to use and easy to deploy that’s also flexible and scalable. Once HarperDB and Ron connected, he discovered that HarperDB could be deployed on devices as small as microprocessors like a Raspberry Pi or Tinker Board, all the way up to large-scale servers, cloud machines, or supercomputers. This piqued his interest, as he needed the ability to do large-scale analytics and move the data between devices in a simple manner. At a basic level, we quickly realized that Ron and the HarperDB team were asking the same questions: When we look at how much data has to move, how much is being created on an hourly basis from OT data onsite etc., how do we manage, transport, and take advantage of all of that data? How do we get the data to where it needs to be in the most efficient manner possible? Extended Functionality Ron said that with HarperDB, he and his team could “define the data movement and do all these crazy cool things.” As they were looking at different military adaptations, they were able to take data that is running integrated into a controller environment (OT) and expose that data without needing to have a human-machine interface (HMI). They could securely move that OT data into the cloud, into a highly scalable enterprise analytics domain powered by HarperDB in the cloud on compute nodes. There are many use cases similar to this, where HarperDB can provide a holistic solution that makes data sync and management easy. In the defense space, HarperDB’s bidirectional data movement enables the collection and movement of data and logic in real-time, shifting decision-making throughout the network as needed. Gaming and media industries benefit from HarperDB’s high performance and low latency, with clear implications for both the organization and the end-user. Retail and ticketing can recognize and block bad bots in real-time with HarperDB’s global replication and edge persistence. The list goes on! You can read more about . industries that benefit from a high-performing, low latency, geo-distributed database here Why HarperDB? Ron explained, “We started looking at all the different databases that are scalable like Couchbase and a bunch of others, but we ended up focusing on HarperDB because of the flexibility. Then, Stephen came up with the idea of Functions because a lot of what we did required us to put an API proxy in front of the data engine. He said, how about I make your life simpler? It’s just amazing how HarperDB checks all the boxes.” Ron continued, “If you think about how databases communicate and the different models, I love the way HarperDB does it through the native integration of all of these components. No matter what it’s running on or where, HarperDB is disruptive because I’m able to move the different types of data, and different types of assets like functionality, from place to place seamlessly without having to worry about the interoperability of different data engines, nor do I have to worry about the size and scale. Databases are not typically designed as persistent vs. non-persistent; they tend to be scaled vertically instead of horizontally. HarperDB scales beautifully; a containerized version of HarperDB tied to persistent storage allows me to scale HarperDB to meet my performance goals. The workload it can perform is amazing, and the ability to actually scale horizontally is amazing as well because it’s not typical for database engines.” Therefore, HarperDB is a unique solution for complex enterprise data challenges because the database engine is small and flexible enough to run on a microcontroller running on an onboard system, that can also be extended to edge bare metal or some edge computing environment for higher fidelity analysis, and can also be moved to the cloud -- all at the speed of the Internet. HarperDB can scale vertically horizontally while meeting performance needs. It really is more than just a database. and To sum it up, Ron stated: “From a data driven ecosystem, HarperDB is paving the path forward moving from mesh to fabric to actual data surface and providing that contextualization of data right out of the database engine, which will be key to a fundamental shift in application behavior.” Predictions for the Future To wrap up our conversation, I asked Ron about the future of technology. He mentioned a few key things: The move from cloud to edge is almost certain. The nature of applications will change to take on a more distributed nature, along the lines of distributed functionality with edge workloads managed and deployed from some cloud orchestrator. As we look at the nature of apps changing, data will be more contextualized from a database engine or persistence layer perspective rather than an application or business layer, and HarperDB is leading the charge on that. There you have it, folks. The future is all about data. There is a constant need for organizations to have their data where they need it, with the ability to orchestrate data where it’s both being created and consumed. If you’re not evaluating your data and how you’re handling your data assets, where will you be in 1, 5, or 10 years from now? Also published here

HarperDB is More Than Just a Database: Here's Why

Node is lightweight & scalable, allows us to develop quickly, and npm has incredible packages. The founding team at HarperDB built the first and only database written in Node.js. A little while back, our CEO Stephen Goldberg was invited to to share the story of this endeavor. Stephen discussed the architectural layers of the database, demonstrated how to build a highly scalable and distributed product in Node.js, and demoed the inner workings of HarperDB. You can watch his talk at the link above, and even read a , but since we all love Node.js and it’s an interesting topic, I’ll summarize here. speak at a Women Who Code meetup (what some called crazy) post from back in 2017 The main (and simplest) reason we chose to build a database in Node is because we knew it really well. We got flak for not choosing Go, but people now accept that Go and Node are essentially head to head ( ). Zach, one of our cofounders, recognized that with the time it would have taken to learn a new language, it would never be worth it. in popularity & community support Pros of building a Database in Node.js We already knew Node.js Lightweight Rapid development Highly scalable npm The HarperDB team has a background in large scale software development. The initial goal of our database was to create a tool that empowers developers to focus on coding, without having to devote time and effort to database maintenance, while still providing a powerful solution. We wanted people to feel comfortable and confident in the product they were using. Our team has extensive experience in languages other than Node, but we had great success programming in it. (Although coming from Java, Stephen thought Node was horrible at first, but after about 90 days he learned to love it). Node is lightweight, allows us to develop quickly, and npm has incredible packages. Cons of building a Database in Node.js At the time was not accepted as an “enterprise grade language” Does not have direct control of Operating System/File System Not as performant as C/C++ (sometimes) Did not have native threading (now it does) We did have some troubles... being the first database written in Node.js we didn’t have the option to follow in anyone’s footsteps. We’re probably one of the first enterprise products ever built in Node, at least the most data-centric one. People questioned this. One guy told Stephen that he would rather cut his heart out with a spoon than program a database in Node.js. We did run into challenges around not having direct control of OS in the file system. Also, C/C++ are faster, but can be more complicated and not necessarily as scalable horizontally. It really depends if you're looking for vertical or horizontal computing. Now people have realized this was a great idea because we have all these incredible features in our product that we didn’t have to build and are inherent in what we do. Tech Stack This is what our tech stack looks like. We consider our to be part of the HarperDB stack, and that is built in React with a Node back end. The green box signifies any application built on top of HarperDB, for example our can be used to build custom workflows. The HarperDB technology is built entirely in Node.js, which encompasses our interfaces and HarperDB core. Management Studio Node-RED node Our product presents itself as a REST API which, under the hood, is essentially just an Express application, that’s the primary interface for how you interact with HarperDB. Our NoSQL parser is a custom solution we built internally. We use AlaSQL for our SQL parsing functionality which you can , we extend their functionality with custom code on top of that, it’s an amazing npm package for parsing SQL. We offer drivers, like ODBC and JDBC, built by a partner of ours. Finally, we use SocketCluster for distributed computing and clustering which . read more about here our CTO presented on in August The HarperDB core technology encompasses the “secret sauce.” This is what makes it possible for us to be fully indexed with no data duplication and offer various interface options to a single data model. Within the core there are numerous npm packages implemented to extend our functionality. Finally we have various options for storage media. We bundle LMDB by default as it provides significant performance gains over the other options. HarperDB core contains extensible code that allows us to add additional storage media options in the future. REST API HarperDB is a set of microservices A single endpoint All operations are post Stateless/RESTful (Sample code found at https://docs.harperdb.io/ ) At a former company our team dealt with the headache of hundreds of API’s with different endpoints, which was simply insane. People might think it’s weird that HarperDB is just one endpoint, but if you look in the body of the code, for every operation you do- all you ever have to change is the body, those first few lines. This is super simple, and when writing a REST-based application you can make it really straightforward. This is something you can take from us and use in any application! Basically you post a single message to the API, we see what operation you’re performing, and handle it with a standard set of methods. We’ve rewritten a lot of our application over the last couple years but this part has stayed mostly the same. Management Studio Built on the HarperDB REST API Written in React Native Allows for control of your HarperDB instances via GUI The HarperDB is a React front end built on top of our microservices (so we eat our own dog food). React is amazing, it’s changed the quality of front end development and allows us to make our application more accessible. By building on top of this, we’re also testing our own API’s at the same time - which makes it really powerful. Jaxon our VP of Product chose React for the Studio, while Stephen wrote our back end reporting in Express. Management Studio One awesome thing about JavaScript is how lightweight it is, regardless of what framework you're using (Node, React, etc), and you can easily couple together these different layers. AlaSQL SQL search is built on AlaSQL https://github.com/agershun/alasql Allows for enhanced SQL Our devs contribute to the project , it has some great things in it that we don’t, and allows us to wire in things like Math.js and GeoJSON so it’s an incredible package. If we had to build our own SQL parser we’d probably still be building HarperDB. It took one of our competitors, FaunaDB, about 4 years just to get to market, but we launched the beta of our product in 6 months, the original version in 12 months, and we just released our cloud product a few months ago (about 3 years later). We chose AlaSQL for HarperDB's back end functionality One amazing benefit of using Node for a language like this is as technology is advancing, most of the cool stuff that you want and need is on npm. We’re not saying we’re geniuses, but by developing in Node we got to stand on the shoulders of people like AlaSQL developers which is what we find amazing about the npm community. Maths.js HarperDB uses math.js functions inside our SQL Allows for enhanced math capability while leveraging the capabilities of npm community Maths.js is another incredible package for things like averages, data science, etc., that we wired into our SQL capability. It’s not hard to use and very powerful in combination with AlaSQL. Clustering/Replication Built on SocketCluster.io Fault tolerant Peer-to-Peer Table level replication Globally shared schema Distributed Computing Another very cool feature of building something in Node.js is that it’s stateless by nature, meaning it does not require holding data in memory that is critical to serving clients across sessions, which is very resource efficient. Most enterprise grade applications have background processes and stateful variables that can become highly unstable. Node is stateless, designed for the web, designed to scale horizontally and to be peer-to-peer. An amazing benefit from using a Node framework is that we were able to wire in SocketCluster to power our clustering and replication. HarperDB uses a simple pub-sub model, so we replicate data by publishing data to different chat rooms which different nodes subscribe to and are able to be distributed horizontally. Node can be horizontally scalable and less resource intensive than other languages, and its stateless nature makes it incredibly stable. By putting Node on lots of computers (horizontally scaling) you can make the framework significantly more powerful while driving down costs, having easier development, and being part of an awesome community. LMDB & File System Originally built our exploded data model on the file system Problematic due to the generation of many files taking up inodes and excess disk space, and other issues Rebuilt data model on LMDB Massive performance gain Originally we were using the file system directly with the above HarperDB data model, this is what makes the product unique. As data comes in, we map it to our data model, it's not a SQL engine or NoSQL engine. We exploded that data into individual attributes and stored them in a folder structure on the file system. We store each thing atomically, and you can query via SQL and NoSQL. We did run into some challenges at scale, so , a key value store that we operate on top of. We were able to implement our exact data model on top of that and it has provided incredible performance gains. , largely thanks to LMDB. more recently we wired in a package called LMDB In a recent benchmark we were about 37 times faster than MongoDB Once again, by leveraging the amazing Node community we are able to focus on what we’re good at. Also published at https://dev.to/harperdb/building-a-database-written-in-node-js-from-the-ground-up-2hgm

HarperDB - How and Why We Built It From The Ground Up on NodeJS

New tech terms and lingo are constantly popping up in the development world. It’s hard to keep up! People also love to share and debate about their favorite tech stacks and tools / frameworks. That said, there is no ultimate right or wrong answer when it comes to choosing a tech stack because it really depends on the specific use case it’s meant to solve for. Today, let’s take a look at the HERN stack. Ever heard of it? It’s a new “buzz word” as they say, and I thought it might be helpful to provide some clarity. The HERN stack stands for HarperDB, Express, React, and Node, the four technologies that make up this particular stack, and they’re all written using JavaScript. This is a full-stack solution that follows a common 3-tier architecture (front end, application, and database). As mentioned, there are numerous stacks out there and different factors play a role in the decision around which is right for your specific end goal. Remember that you have the freedom to choose and try different stacks! To make sure we’re all on the same page, Stackshare defines a tech stack as “the set of technologies an organization uses to build a web or mobile application. It is a combination of programming languages, frameworks, libraries, patterns, servers, UI/UX solutions, software, and tools used by its developers.” So as you can see, the combinations and possibilities are endless! What Makes up the HERN Stack? Distributed SQL / NoSQL hybrid database accessed via a REST API. HarperDB : Open source, back end web application framework for Node.js, designed for building web applications and APIs. Express.js : Open source, front end, JavaScript library for building user interfaces or UI components. React.js : Open source, cross-platform, back-end JavaScript runtime environment that executes JavaScript code outside a web browser. Node.js : There are several reasons that these technologies work well together and serve as a great full-stack solution for projects like app development and web development. There are also variants of this stack that would work just as well, such as swapping out and incorporating frameworks like Vue, Angular, or . HEAN, HEVN, HFRN… don’t be afraid to get creative and choose what technologies make the most sense for you! Fastify How Does the HERN Stack Work? Like most tech stacks, this one has a frontend, backend, and database tier. The HERN stack allows you to write everything in Javascript, ultimately simplifying and streamlining the development process. Each component of the HERN stack provides a unique benefit, and data flows naturally through each of the three tiers, enabling rapid development and simple upkeep. ( !) Fun fact - HarperDB is actually the only database that was built from the ground up in Node.js, which you can read more about here Frontend React serves as the frontend or web tier of the HERN stack. Among the many reasons React is , it enables faster development, simplifies coding and integration, and comes with a strong community. The HarperDB was written in React. React has improved the quality of front end development and allowed us to quickly make changes and improvements to our application. taking over frontend development Management Studio HarperDB also provides a great , if that’s your style, or you could make calls directly to HarperDB via our built-in, easy to use API. Either way, you can query data directly from within your client-side application if you choose. are a great place to manage your API calls and how responses are handled within your app. React SDK React Hooks Backend Node.js and Express.js serve as the backend, server, or application tier of the HERN stack. Express essentially operates inside a Node server, as the server-side framework. is a minimal and flexible framework, with numerous HTTP utility methods and middleware at your disposal. Express The idea here is that you build your custom API functions (GET, POST, etc.) with Express to be called by the React front end. These functions then make calls from the server to HarperDB to access and modify the database. You can utilize the HarperDB , which natively supports promises and callbacks. The library makes HarperDB interactions feel more native to JavaScript by exposing each HarperDB operation as a function on the client object. Node.js client Database If you need to store or transport any type of data, which you probably do, you will also need a database. Why not choose the quickest, easiest, and most intuitive database out there? HarperDB provides full document store capability plus enterprise grade ACID-compliant SQL, effectively allowing you to run SQL on JSON. The database is accessed via a single endpoint REST API using SQL and NoSQL operations. HarperDB has simplified much of the work when it comes to database installation, configuration, and administration. It’s really a great option for developers of any skill level. Check out if you’re building in the cloud, or you can also do a local . HarperDB Cloud install on your server Is HERN Your Next Full-Stack Solution? You can essentially build anything with the HERN stack, and it’s especially great for JavaScript developers and projects with lots of JSON data. With a dynamic schema, HarperDB was designed to ingest and handle any type of data at scale. You no longer need to pick a database based on the structure of your data. HarperDB provides the flexibility to work with the frameworks of your choice, and ability to connect to your favorite reporting or analysis tools. Scaling is easy with HarperDB’s clustering and replication features, and our data model, built on top of LMDB, is enabling us to break records on both read and write speeds. HarperDB works extremely well with Express, React, and Node, and with this tech stack you can maximize your time writing code, and work on your project instead of debugging and other administration tasks. Don’t get stuck in your old ways! Try the new HERN, HEAN, or HEVN stack and let us know what you think. We would love to hear what you’re working on! Also published at https://dev.to/harperdb/hern-stack-comin-in-hot-pa6

Along Came HERN Stack

318 Stories To Learn About Reactjs

199 Stories To Learn About Python Tutorials

Let's learn about via these 47 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Postgres /Learn Repo 1. Using a Relational Database to Query Unstructured Data Using Relational Database to search inside unstructured data 2. Postgres: Idle queries and pg_locks Getting postgres unstuck when it seems to “hang” or be super slow on queries 3. How to Connect Your Bastion Server to a PostgreSQL Server with an SSH Tunnel In this article, you'll learn how to connect to an RDS server through a bastion server in Bash using an SSH tunnel. 4. Multi-tenant Postgres In The Real World Back in the days when MySQL was the undisputed open source database champion, there was a sense that people who took their databases seriously would choose PostgreSQL instead. Everyone else chose MySQL; it was fast and it was easy. 5. How to query JSONB, beginner sheet cheat Let’s say we have to query a user table with a metadata JSONB column on a PostgreSQL 9.5+ database. 6. SQL Databases Vs. NOSQL Databases The decision to choose a database  for project is not that simple. But when it comes to choosing a database, the biggest decisions is picking a relational (SQL) or non-relational (NoSQL) data structure. 7. Finessing Postgres into an Insane 200x Faster Query Plan This article will show you a real-life optimization story and how PostgreSQL row count estimation can go very wrong when trying to get a faster query plan 8. Take your Materialized Views to the Next Level by Joining MySQL and Postgres 9. How To Decode Django Sessions in PostgreSQL When solving a problem that requires you to link a user's session data to their actual user object, Postgres comes in handy. 10. How To Run PostgreSQL as a Build Requirement in TeamCity Build We use different Continuous Integration tools in our projects. One of them is TeamCity software. A pipeline for TeamCity can be configured easily and has two steps, such as run tests and build a docker image for further deployment. However, I needed to run Postgres before running tests. I made a research, I read the documentation and this article may be useful to close a gap for team city’s documentation. 11. How to Build a Decoupled Microservice Using Materialize One way to handle data in microservice architectures is to use decoupled microservices architecture. This form of architecture can bring many benefits. 12. PostgreSQL Change Data Capture and Golang Sample Code PostgreSQL offers Logical Decoding Method to make log-based change data capture possible. Setup and run CDC in several steps. 13. Connecting GraphQL with Java Spring Boot and Postgres or MySQL GraphQL is revolutionising the way developers build APIs. It lets you query precisely what you want. Nothing more, nothing less! It also gives you the flexibility to query related objects in a single round trip, unlike the REST APIs. 14. Taking a Closer Look into Google's AlloyDB Architecture for PostgreSQL An exploration of AlloyDB's architecture and design, focussing on its storage engine, with descriptions of how it handles reads and writes 15. Time For Me To Fly… To Render Heroku has eliminated their free plans, so I’m migrating to Render for my prototype products and services. Let’s see how easy it is to convert to Render PaaS. 16. Changing Database Column in Rails 5 While working on a Rails application, we all have had to change the database column in some way. You can change the column name and the column type, as well as changing the column with the type conversion. 17. Your Guide To Schema-based, Multi-Tenant Systems and PostgreSQL Implementation There are several architectures that could be followed to achieve multi-tenancy at the database layer. 18. PostgreSQL vs. MongoDB: Evaluating Database Structure, Speed, and More Choosing a database can be scary as it’s nearly impossible to change once you’ve built on one. So which will you choose? PostgreSQL or MongoDB? 19. Tutorial: Build AdonisJS API to store your Raspberry Pi Temperature In this tutorial we will use AdonisJS to build a simple API that will collect the data from the sensors and store it in a Postgres database 20. How to Stream Data from MySQL to Postgres Stream MySQL data to PostgreSQL in real-time. Any changes made to your source immediately applies them to the target database. 21. An In-depth Look Into MySQL Vs. PostgreSQL PostgreSQL and MySQL are both reliable, secure and scalable databases that have been around for years. 22. How to Test Your Postgres Business Logic with Jest Plugin With great power comes great responsibility and the bigger the project gets the easier it is to break something. Therefore you should test Postgres logic! 23. Debugging with Render: Two Effective Methods When you use Render to deploy your Node.js application with Postgres database, you can debug easily with integrated tools like Datadog and Log Streams. 24. A Mistake That Could Cost You Millions: What it Is and How to Fix It This small golang mistake could cost your business a million-dollar problem. You could easily avoid the mistake read the blog 25. Which Database Is Right For You? HarperDB vs. MongoDB vs. PostgreSQL The purpose of this article is not to determine which database is the best but to help determine which is a fit for your specific project. 26. PGSync Introduction: Real-time Integration Tool For PostgreSQL And Elasticsearch PGSync is a change data capture tool for moving data from Postgres to Elasticsearch. It allows you to keep Postgres as your source-of-truth and expose structured denormalized documents in Elasticsearch. 27. How to Efficiently Generate Test Data With SQL There are a large number of utilities for generating test data. Here are some examples of using SQL queries to generate test data. 28. What is the Significance of Time-Weighted Averages in Data Analysis Learn how time-weighted averages are calculated, why they’re so powerful for data analysis, and how to use TimescaleDB hyperfunctions to calculate them faster. 29. Unlock the Power of ACID Properties in Databases: A Comprehensive Guide for Developers ACID stands for Atomicity, Consistency, Isolation and Durability and each of these have a specific purpose when it comes to databases. 30. Node.js Streams in Action Ever wondered how streams are working in Node.js? I had. So far I know that using streams will most certainly reduce memory usage on the server when processing large files. Instead of reading whole file into memory we stream it in chunks to whoever requested it and apply transformations to that stream if needed. That's huge benefit as it allows to avoid vertical scaling. Processing files is common task but not as common as interacting with databases and that's going to be my focus now. I'll build simple API with 2 endpoints. Both will be returning large amount of records from Postgres DB. One endpoint will stream data to the client and another will read whole data into memory and return in one chunk. 31. Postgres and MySQL: Performance Comparisson What workload analysis and running queries can teach us about the performance differences in JSON, indexing, and concurrency. 32. 6 Reasons You Should Transition to PostgreSQL from Oracle As opposed to proprietary solutions (like Oracle), you won’t get locked in with ever-escalating license fees. Here are 6 reasons you should move to PostgreSQL. 33. How to Use Postgres to Recreate YikYak YikYak was an anonymous social network that used your location to show you posts 5km around you. Users of the app could create new posts and the people around them could view the posts and vote up or down. 34. Introduction to RDS Proxy: Exploring with Benchmarks in Go A deep dive into the performance characteristics of RDS Proxy vs RDS 35. PostgreSQL Transaction Isolation Levels with Go Examples Illustration composed from MariaLetta/free-gophers-pack, original gopher by Renee French. 36. Database Connection Pooling With pgbouncer Introduction: The Postgres Connection Pool Problem 37. Streamlining Your Django Development Environment with Docker Containers Learn how to containerize an entire Django project from the ground up, including a Postgres database, Redis cache server, Caddy, and Celery instances. 38. How To Create A User Portal On Airtable With Sync Inc And React In this tutorial, you’ll see how to build a scalable, secure, and flexible client portal on Airtable using Sync Inc, Cotter, and Next.js. 39. Hunting for Customers With PostgreSQL Now more than ever, you have to hold onto every customer you can. Customers don’t love your product one minute, then fall out of love with it the next. Normally there’s a declining trend in usage of your product over time. 40. How to Set up a Heroku Postgres Database with Librato In this article, you will learn how to set up a Heroku Postgres database with Librato for automated monitoring. 41. Percentile Approximation Vs. Averages Get a primer on percentile approximations and why they're useful for time-series data analysis. 42. Database Monitoring and Alerting with n8n 📡 In the past few months, I have been playing around with different kinds of IoT devices and sensors. I quite enjoy how these can be used to monitor different things like humidity, temperature, pressure among other things in the house. In this tutorial, I want to show you how you can monitor sensor readings in a database and send alerts when it crosses a threshold value using n8n workflows. 43. How To Create and Load Test Data in PostgreSQL Learn what tools and approaches are available to create and load test data for webapps without an ORM. 44. Log Slow Postgres Query Plans Automatically: An Introduction to auto-explain Automatically log slow query plans with auto_explain and learn how to fix the problematic PostgreSQL queries that are slowing you down. 45. How to Add Knex to ExpressJS Apps and Connect to a Postgres Database Express is one of the most popular JavaScript frameworks for building backend APIs and Postgres is a really popular relational database. How do we connect them? 46. SaaS Database Migration To Heroku Postgres The next step in my fitness application journey is to migrate to Heroku Postgres. Check out how easy this turned out to be too. 47. Top 12 FAQs About PostgreSQL PostgreSQL is an open-source, object-relational database management
system (ORDBMS) available for all major platforms including Linux, UNIX,
Windows, and OS X. It allows you to add custom functions developed using different programming languages  such as C/C++, Java, etc. It is designed to handle a range of workloads, from single machines to data warehouses or Web services with many concurrent users. It is the default database for macOS Server. Thank you for checking out the 47 most read stories about Postgres on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

47 Stories To Learn About Postgres

Let's learn about via these 52 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Nosql /Learn Repo 1. How Useful is PostgreSQL Full Text Search PostgreSQL is the jack of all trades when it comes to databases. It brings you all the features you've come to love about SQL plus a bunch of features from Non-SQL databases. Some of these Non-SQL features like the JSONB data type are wonderful and you don't even have to dare flirt with another database. Others are good but not as robust and featureful as other databases. 2. A Quick Start Guide For MariaDB Get started with MariaDB with just three steps using the official MariaDB docker container. 3. Storage Options for Serverless on AWS Serverless computing enables you to run functions without provisioning resources. Most of the top cloud providers offer good serverless options, but this article offers a review of storage options for serverless on AWS. First, you will learn about the core principles of storage and data persistence in serverless computing, and then you'll discover what serverless options are available on AWS for databases, microservices, IoT, and storage synchronization. 4. NoSQL vs SQL: Comparison From the Development Team Let’s dive into the main types of databases, their main features, and their working principles. And also development differences to be more practical. 5. How Percolate Queries in Elasticsearch Make Alerting a Breeze Once upon a time, a company I worked for had a problem: We had thousands of messages flowing through our data pipeline each second, and we want to be able to send email and SMS alerts to ours users when messages matching specific criteria were seen. 6. Comparing Different Time-Series Databases A comparison of data models used in open-source SQL and NoSQL time-series databases for IoT. 7. Is GraphQL Still a Thing in 2020? GraphQL has become the most loved tool for API development in a very short span of time, and developers across the world cannot seem to get enough of it. Today I met with the founder of Windsor.io, Pranay Prakash, who has worked on the team behind GraphQL during his time at Facebook. I chatted with him to find out more about his experience working closely with Lee Byron, the creator of GraphQL, and some of GraphQL’s benefits. 8. Should You Be Using NoSQL? NoSQL got quite some hype a few years back. It was going to solve your scaling, uptime, and speed problems. There were trade-offs, of course, but, for a brief moment, seemingly everything we knew about storing and querying data was up for grabs. 9. Data Lakes Are Crucial To Business Analytics and Big Data Processing While the term Data is in cognizance of business of all sizes even the most layman person is aware of the buzz and fuss around Data. So from Database to Data Warehouse and now this Data Lake, we have come a long way. 10. Going From Data Lakes to Oceans Aggregating into data lakes is the solution of today — but are Federated Sources the solution of tomorrow? 11. MongoDB 101: A Free Course By Academy 3T MongoDB is a document-based NoSQL database, typically used for its ability to quickly scale, especially large amounts of data. MongoDB has two clear main benefits over SQL when it comes to data organization: 12. How to Choose the Right Database for your Requirements Imagine — You’re in a system design interview and need to pick a database to store, let’s say, order-related data in an e-commerce system. Your data is structured and needs to be consistent, but your query pattern doesn’t match with a standard relational DB’s. You need your transactions to be isolated, and atomic and all things ACID… But OMG it needs to scale infinitely like Cassandra!! So how would you decide what storage solution to choose? Well, let’s see! 13. Everything You Need to Know About AWS DynamoDB AWS DynamoDB changed the database game in Serverless and continues to do so, as its design repeatedly proves its huge value. 14. Exploring the Neo4J Graph Database In this article you'll learn more about the NoSQL Graph database - NEO4J. 15. How to Use .populate() With mongoDB How to use populate() method with mongoDB to itch data across referenced collections 16. 5 Ways to Store Market Data: CSV, SQLite, Postgres, Mongo, Arctic What's the most efficient way to store market data? SQL or NoSQL? Let's compare 5 most common options and find out what is best. 17. Graph Databases: How Do They work? Heard lots of things about graph databases and do not know where to use them? Here is an ultimate description for you: use cases, explanations, and examples. 18. Do Modern Technologies Like Serverless Really Offer Better Benefits? Remember mainframes? Serverless is pretty much that: we own the machine and you rent out time on our big iron. We went full circle on progress! 19. Creating Developer-Friendly Data Services with Apache Cassandra Using data APIs and advanced data modeling will make it far easier for JSON-oriented developers to connect to Apache Cassandra. 20. Which Database Is Right For You? HarperDB vs. MongoDB vs. PostgreSQL The purpose of this article is not to determine which database is the best but to help determine which is a fit for your specific project. 21. Hexagonal Architecture: the practical guide for a clean architecture Did you ever face problems when comes the time to upgrade the stack of your software? Are you able to distinguish your functional tests from your integration ones? Migrating your legacy means rewriting everything from scratch?
Discover how the Hexagonal Architecture, a clean architecture pattern also known as Ports and Adapters, can help! 22. PGSync Introduction: Real-time Integration Tool For PostgreSQL And Elasticsearch PGSync is a change data capture tool for moving data from Postgres to Elasticsearch. It allows you to keep Postgres as your source-of-truth and expose structured denormalized documents in Elasticsearch. 23. A Guide to Using MongoDB Database in a ASP NET Core Web API Application When you think about database providers for ASP NET Core apps, you probably think about Entity Framework Core (EF Core), which handles interacting with SQL databases. But what about the NoSQL options? A popular option for NoSQL is MongoDB. So in this article we're going to learn how to create a simple ASP NET Core CRUD API using MongoDB as the database provider. 24. InfluxDB: From Open Source Time Series Database to Millions in Revenue The InfluxBD Origin Story: How Paul Dix took a failing SaaS product and turned it into a successful commercial open source time series database company. 25. SQL Databases Vs. NOSQL Databases The decision to choose a database  for project is not that simple. But when it comes to choosing a database, the biggest decisions is picking a relational (SQL) or non-relational (NoSQL) data structure. 26. When to Use a Relational, Non-Relational, or Graph Database Graph databases are anticipated to surpass other types of databases, especially the still-dominant relational database. 27. An Introduction to Blockchain + NoSQL Databases Both NoSQL databases and modern Blockchain ledgers benefit from a set of common principles. When they are both implemented for an application, a lot can be accomplished as the platforms can complement each other. 28. Why We Should Have Different Databases Today there are hundreds of SQL and NoSQL databases. Some of them are popular, some are ignored. Some are user-friendly and well documented and some are hard to use. Some are open sourced and some are proprietary. And, perhaps, the most important - some are scalable, optimized, highly available and some are difficult to scale or maintain. 29. Design for E-Commerce Apps Using a NoSQL Database Working with a lot of data like products, orders, categories, users and payments is a very important topic when building e-commerce applications. In this post you'll learn the very basics of structuring your noSQL schema so it's fast and scalable for e-commerce scenarios. 30. Most Common Redis Use Cases by Core Data Structures Redis, short for Remote Dictionary Server, is a BSD-licensed, open-source in-memory key-value data structure store written in C language by Salvatore Sanfillipo and was first released on May 10, 2009. Depending on how it is configured, Redis can act like a database, a cache or a message broker. It’s important to note that Redis is a NoSQL database system. This implies that unlike SQL (Structured Query Language) driven database systems like MySQL, PostgreSQL, and Oracle, Redis does not store data in well-defined database schemas which constitute tables, rows, and columns. Instead, Redis stores data in data structures which makes it very flexible to use. In this blog, we outline the top Redis use cases by the different core data structure types. 31. How to Back Up and Restore a MongoDB Database MongoDB. Seven Ways to Back Up and Restore Data 32. NoSQL: A Brief History and the DynamoDB Challenge Dynamo accelerated the NoSQL revolution that’s driving the database industry. 33. Top 3 Databases Every New Developer Should Know Most new developers wonder which database is suitable for their project since they don't want to get off on the wrong foot. So, first and foremost, let's define a database. A database is a type of storage facility that electronically stores and organizes data so that it may be utilized and accessed later. 34. 2019 Database Trends – SQL vs. NoSQL, Top Databases, Single vs. Multiple Database Use Wondering which databases are trending in 2019? We asked hundreds of developers, engineers, software architects, dev teams, and IT leaders at DeveloperWeek to discover the current NoSQL vs. SQL usage, most popular databases, important metrics to track, and their most time-consuming database management tasks. Get the latest insights on MySQL, MongoDB, PostgreSQL, Redis, and many others to see which database management systems are most favored this year. 35. 6 Common DynamoDB Issues in 2022 It’s expected that developers face many of the same issues when starting their NoSQL journey with DynamoDB. This article might clear things up a bit. 36. How To Query JSON in Couchbase via Collections and Scopes This week I’m attending the 3-day Couchbase Connect event and will be reporting on some of the topics that I find most interesting. 37. The Pros and Cons of NoSQL Learn how NoSQL differs from SQL and how it's built for high performance and availability. And no, it doesn't stand for "No SQL". 38. How to Connect MongoDB(4.2.10) and MongoDB Compass Locally What is MongoDB? 39. Ten Underground Tech Masterminds You Probably Haven't Heard Enough About The history of technology, intended here in a narrow sense as the history of information technology, rests on the shoulders of a small handful of giants. 40. Hadoop Data Storage Explained Explore how exactly distributed storage works in Hadoop? We have to characterize an essential node (known as NameNode) from one of the workers (DataNodes). 41. How to Run Node.js with MongoDB [Tutorial] Many of today’s web applications use node.js in conjunction with MongoDB to store and access data on the backend server. Not only does node.js excel in ease of access to non-relational databases like MongoDB, but brings scalability and speed to the server side of your app. 42. Implementing A Distributed Multi-document ACID Transactions in Couchbase: A How-To Guide A story about how we implemented support for distributed transactions with no central coordinator and no single point of failure. 43. How to Design a Web Application: Software Architecture 101 So you’ve embarked on the entrepreneurial journey to build your own web application. You’ve got the idea in place, but the significance of getting the architecture right is extremely important. 44. A Snap Is Worth A Thousand Words (Podcast Transcript) Is database migration as scary as it sounds? Amy Tom talks to Matt Groves, Senior PM Manager at Couchbase, and Curt Gratz, Co-Owner of CKH Consulting. 45. Dealing With Replication, High-Performance Queries And Other Data Platforms Challenges Many products solve for global issues and load balancing but unless a platform is built from the ground up with the necessary backbones, it becomes a nightmare to manage. 46. Are NoSQL databases relevant for data engineering? In this article, we’ll investigate use cases for which data engineers may need to interact with NoSQL database, as well as the pros and cons. 47. What is SQL? And Where is it Used? What is SQL? Databases use it, query APIs use it, even energetic big data dashboards use it! Where did it come from and how are developers, DBAs, and app using. 48. A Comprehensive Guide To Database Architectures And Use Cases This article will provide an overview on database architectures, including use cases and pros & cons for each of them. 49. Building a MongoDB NoSQL E-Commerce Data Model MongoDB supports ACID transactions, and its cloud offering is PCI DSS compliant. It's one of the best NoSQL options for e-commerce. 50. How to Create World Leading Databases Jason Repp is the SVP of HarperDB, a world-leading ﻿database and development platform that is leading the charge in terms of performance, flexibility, and ease. 51. Migration Makes My Skin Crawl: From SQL to NoSQL Is database migration as scary as it sounds? Amy Tom talks to Matt Groves, Senior PM Manager at Couchbase, and Curt Gratz, Co-Owner of CKH Consulting. 52. How to Achieve Schema and Validation in NoSQL Using Ottoman and Couchbase Ottoman is an Object Data Modeler (ODM) for Couchbase's Node.js SDK providing JSON schema and validation for a NoSQL database. Thank you for checking out the 52 most read stories about Nosql on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

52 Stories To Learn About Nosql

Let's learn about via these 48 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Npm /Learn Repo 1. How to Install Node Versions and Upgrade or Downgrade Them Learn the best way to install Node and keep it up to date. 2. How To Set Up a tsconfig For Nodejs Learn how to easily setup a tsconfig file to build for nodejs. 3. In Layman's Terms, What is the Difference Between Node and Deno? Worried that dinosaur or sock shaped "deno" is going to kill our favorite  Node? Let me help you to get out of this dilemma. 4. Tutorial: Creating New Node.js Projects and Working with Packages After you've set up Node.js on your machine, the first thing you'll probably want to do is create a new project and start coding. And to get more efficient at the job, there are two important things that you'll need to be fluent with: 5. A Beginner's Guide to NPM Package Manager in 2022 In this tutorial, you will learn about the basics of NPM for beginners, with everything you need to know about package.json, npm ci & audit. 6. Using Open Source AWS Amplify JS with Cognito to Secure Angular Apps This article shows how to set up the Cognito UserPools JWT authentication flow and how it will integrate with an Angular Web Application. 7. How to Create and Publish Your First NPM Package A Comprehensive Guide To Creating and Publishing Your First NPM Package 8. Publishing a Node.js CLI tool to npm in less than 15 minutes Have your Node.js CLI tool up and running, accessible from everywhere in less than 15 minutes. 9. How To Stay On Top Of Your Dependency Management Dependencies are exactly what it sounds like - things that you depend on. But take that undeniable statement into your software project and you soon find out that it’s not just you who depends on them. It’s entire teams, processes, projects, infrastructure, and, most important of all, your clients. 10. How to fix Security Vulnerabilities in NPM Dependencies in 3 Minutes Hola people!!! 🥑 11. How to Deploy React JS Applications for Free on Firebase In this article , I’ll take you through all the steps involved in deploying a your React app on firebase. 12. Open-Sourcing Regular Expressions for Markdown Syntax Module Arthur Tkachenko describes this process of open-sourcing a npm package for working with regular expressions: https://github.com/atherdon/markdown-to-email 13. Publish NPM packages using GitHub Actions: A How-To Guide NPM automation tokens allow us to publish 2FA-protected packages from automation workflows. 14. How to Upload to Amazon S3 via AWS CLI and NPM scripts Static websites are a brilliant way to create performant sites. My website is built using Gatsby and hosted on Amazon S3. I have created a simple script to help you quickly upload your site to S3 by running one simple command in your project terminal. 15. Getting Started with MariaDB using Docker and Node.js It's no secret that MariaDB has become a popular database solution for developers over the past decade. Why? Well, one could argue that it's largely because it's open source and relational. So, for developers, that basically means it's free, and we get the gist of it. But that really only begins to scratch the surface. 16. The Difference Between Angular, NPM, and Node.js There's a lot of confusion around the terms Angular, NPM, and NodeJs. What are they? And how do they interact with each other? 17. How to Create and Publish Your First Private NPM Package In this article, I will  show how we can easily create our first private npm package. 18. Automate JavaScript deployment of npm packages with Github actions What does Factorio and CI/CD pipelines have in common? 19. How to Help the Dev Community by Solving your Own Problems How to continue to use Open Source developments in 30 years - a brief instruction for use. 20. Building a Simple CLI with oclif Instead of using shell scripting languages, software developers looking to build their own CLI tools can use the oclif framework to build with Node.js. 21. Beginners Guide to Node.JS Introduction to Node.JS 22. 15 Best Web Development Tools To Use In 2021 Here are the best tools for web developers. Here is a list of tools that you can use to build your website, and all of them are useful. Read this article to get 23. A Guide to Embedding and Playing YouTube Videos in React Native Apps Embedding and playing YouTube videos in your React Native app is seamless and a more affordable way of displaying videos in your app 24. Locking down your API_KEY and why that is important Do you leave your keys inside your car in a big parking lot? If not, then why do you expose your API_KEYs in your Github projects? 25. The 36 Most Depended Upon NPM Packages source, https://www.npmjs.com/browse/depended. The ordering, descriptors, and publisher accreditation are coursey of npmjs.com. 26. HarperDB - How and Why We Built It From The Ground Up on NodeJS The founding team at HarperDB built the first and only database written in Node.js. Here's the story of this (what some called crazy) endeavor. 27. Why NPM and Yarn f*cking suck Opinion piece: What we can learn about documentation and logging 28. The Only API You Need! "The Only API" is an open-source SDK that allows developers to query for anything they need in any data format. It has limitless capabilities. Try it now! 29. Organizing an Advanced Structure for HTML Email Template I was rebuilding a part of our markdown-to-email repository. I was not happy with how we handle templates in our generator. 30. Getting Started with MariaDB using Docker and Node.js It's no secret that MariaDB has become a popular database solution for developers over the past decade. Why? Well, one could argue that it's largely because it's open source and relational. So, for developers, that basically means it's free, and we get the gist of it. But that really only begins to scratch the surface. 31. How to Write a Simple NPM Package Imagine that you don't need any compiler or bundler to prepare your NPM package written in ES2020 standard. Yes, you can. 32. These 6 essential tools will release, version, and maintain your NPM modules for you Learning how to implement them for your own projects will save you a ton of time! 33. How to Use Lerna to Create a Monorepo for Multiple Node Packages In this post, we will walk you through how to use Lerna to manage, and publish, multiple packages under the same monorepo 34. Managing NPM Dependency as A Professional Why do we talk about project quality and technical debt so much? Because this directly or indirectly affects the speed of development, the complexity of support, the time to implement new functionality, and the possibility of extending the current one. 35. The Most Convenient Ways of Writing Transactions Within the Nest.js + TypeORM Stack If you have some troubles with transactions in Nest.js - this article will help you. 36. How to Build a Command-line Utility (CLI) with Node.js CLIs built in Node.js are highly portable, meaning they are easy to install on a different OS. We’ll be building a simple CLI to translate between languages. 37. Creating a Forum CMS with React.js and Ruby on Rails In this project, we will be using React.js, Ruby on Rails, React-Quill, and Cloudinary to build a forum whose content is manageable by the site's users. 38. Introducing a Simple NPM Module with Email Templates From novice developers to experienced ones, most are involved in sending emails programmatically. Read on to know the need for a default email template package. 39. Understanding Project Dependencies Through the NPM Lens Code dependencies are like Lego's. We're able to pull in other people's code; combining and stacking different packages together to fulfill our goals. 40. The Developer's Guide to Updating npm Packages A simple guide for updating for npm packages. 41. Chrome Extention That Will Enable Dev Snippets on Google Search Results Are you too lazy to click on search results to see the actual Stack Overflow answer, npm install instructions or the GitHub repo's README.md file? 42. 15 Lodash Methods for Everyday Coding The Lodash open-source library has some useful methods that can help developers write code faster and streamline their processes to improve their work. 43. How to Create an Angular Library to Publish on NPM Libraries and packages help to abstract reusable code and improve efficiency during development. Learn how to create libraries for the Angular ecosystem. 44. Node Version Manager (NVM): How to Install and Use (Step-by-Step Guide) In this article, I will tell you how to install Node Version Manager (NVM) on your computer step by step in a more optimal way. 45. A Guide to Composing and Integrating APIs Together With React/Next.js, the fundamental problem you’re solving is that of turning some notion of ‘state’ into DOM, with a focus on composability 46. NPX Introduction: Fast Work With NPM Package Binaries With Node.js, building CLI utilities and development tools have gotten so much easier. 47. Improving Our MongoDB Write Throughput with SQS Deep dive on how we got our MongoDB load at a steady sub 50% CPU load by using an SQS layer between our Node application and the database to save costs. 48. Introducing a Simple NPM Module for Food Measurements Hello! I've created a simple JavaScript module for food measurements. Thank you for checking out the 48 most read stories about Npm on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

48 Stories To Learn About Npm

Let's learn about via these 67 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Node /Learn Repo The most hated language powering web servers since PHP. 1. How to Set the Default Node.JS version with nvm 2. Crypto-Biometrics Helps Create Decentralized Pseudonymous Identities Using private biometric technology, Humanode will be the first crypto-biometric network where one human equals one node. 3. How to Act Like You're Working When You're not With RobotJS Learn how to automate your desktop but with a fun example. 4. How Libuv Thread Pool Can Boost Your Node JS Performance In this 5th instalment of my “Node JS Performance Optimizations” series, I show you how to increase Node JS performance with thread pool management. We achieve this by understanding how Libuv works, how the thread pool works and how to configure the number of threads based on your machine specs. 5. In Layman's Terms, What is the Difference Between Node and Deno? Worried that dinosaur or sock shaped "deno" is going to kill our favorite  Node? Let me help you to get out of this dilemma. 6. A Simple Sequential and Parallel Task List Runner for Terminal Taskz is a library for Node.js, a simple sequential and parallel task list runner for terminal. 7. Web Scraping Using Node.js While there are a few different libraries for scraping the web with Node.js, in this tutorial, i'll be using the puppeteer library. 8. Why Should I Use Nodemailer to Send Emails? A useful guide on how to use Nodemailer to send emails. 9. Power Up Your Logging in Node.js Power up your logging and build good developer habits. As your codebase grows you'll need to debug it more easily and one tool is logging. 10. What’s New in Swell 0.6.0? Swell is a cross-platform compatible (Mac, Linux, & Windows) desktop application and the leading API dev tool for testing and visualizing steaming TCP connections (i.e., WebSockets, SSEs, GraphQL subscriptions). Swell functions similarly to Postman, but with the added perks of full streaming and GraphQL support. Being an Open Source project, Swell is 100% free and open to outside contributions. For details on how it works, see our previous article here. 11. My List of Crypto-Programming Youtube Tutorials A collection of my youtube videos on creating bots for trading, creating smart contracts, building dApps, and integrating with Facebook, Amazon, and eBay APIs 12. How to Exploit Prototype Pollution? Prototype Pollution is a JavaScript related vulnerability. This article explains how it works and how to exploit it bypassing security checks of the app. 13. The Quickest and Most Secure Way to Run Your Blockchain Node This article tells you the quickest approach to running a blockchain node. You can save yourself a lot of time reading it! 14. Assign Types To Nested Objects In TypeScript TypeScript provides you with multiple ways to define type definitions for object properties. We'll look at a couple of them throughout this post. 15. The Differences Between Deno and Node Deno a pristine method to compose worker side JavaScript. It solves many of the problems as Node. 16. The Art & Science of Node Monitoring One of the hardest parts of designing a monitoring system is predicting everything that “might” go wrong. That only comes from experience, not just over time, b 17. How to Scrape Data From Any Website With JavaScript Learn how to scrape the web using scripts written in node.js to automate scraping data off of the website and using it for whatever purpose. 18. Exploring the Neo4J Graph Database In this article you'll learn more about the NoSQL Graph database - NEO4J. 19. How to Get a Cookie’s Expiry Value on a Server Browsers handle cookie expiry so they don’t pass the cookie’s expiry value to the server. 20. Node Providers The node provider market is crowded. New players have few opportunities: support long tailed assets, better UX, lower price. 21. When to Use Node.js for Your Web Application Want to know what is NodeJS and Why You Should Use It? Here is detailed blog covering every minute detail of NodeJS. 22. How to Deploy an Express Node.js Application to Heroku Quickly and Easily Deploy your Express Node.js application to Heroku in just a few steps. This is a step-by-step guide on how to deploy your app to Heroku. 23. Gearing Up for Marketing Mumbo Jumbo: A New Squeeze Page + Blog! Celebrating 20% gains in about a day, we're preparing to launch our first-ever marketing collabroation with the team and friends over at CryptoCatBot where we might even feature in their products section and/or get an email blast - for a marginal trade of referral commission, tbd - stay tuned for our glorious launch celebration in Telegram :) 24. What Roles Do API Methods Play On The Blockchain? Read on to find the detailed info on such Blockchain API methods as JSON-RPC, REST and WebSockets, the main use of API and how it's related to cryptocurrency. 25. When ORMs Disobey: A Mongoose Story In hindsight, it seems like mongoose was doing the sensible thing by simply ensuring that the document existed in the database. 26. Coinbase Cloud Node & NFT APIs Building upon his last publication, John Vester dives even deeper into Web3 by leveraging new tech by Coinbase Cloud to create a more functional dapp. 27. Node-RED Module for Visual NodeJS Programming In this article, I'm going to introduce you to a NodeJS module that allows you to create and deploy server-side processes by using a visual, drag n drop style. 28. HarperDB: Build Your Application Backend in One Place with Custom Functions Introducing the newest innovation from HarperDB: HarperDB Custom Functions. With the release of HarperDB 3.1 users are able to define their own API endpoints within HarperDB. What does that mean for you? HarperDB grows from a distributed database to a distributed application development platform with integrated persistence - one that can serve as a single solution for all of your backend needs. We’re collapsing the stack! 29. Cz-git Recipes - Easy to Commit 🔨 A more engineered, highly customizable, standard output format commitizen adapter. 30. What is a Dapp? And What it Most Definitely is Not. Definition 31. Moe-js - A Modern Template Engine for JavaScript I've been using Handlebars in Node.js apps for a long time now and while it always gets the job done, sometimes I find it awkward to use.  In particular I miss being able to use expressions and flexible logic flow directly in the templates.I know there's an argument for keeping logic and views separate and that views should be "logicless", but sometimes you just want a bit more control.  The existence of libraries like Swag, suggests that I'm not alone here so I got to thinking... 32. How To Earn With Play-to-Earn: Basics of Hottest Crypto Trend Right Now Play-to-Earn or GameFi protocols became mainstream in Q3-Q4, 2021 - and euphoria around them still gains steam. 33. Microservices Deserve Modern Programming Platforms: Java May Not be the Best Option Microservices are very popular today, even in traditional corporate IT shops. Often though they are implemented using languages, such as Java, born in the early ’90s and designed for a world of monolithic applications. Do you remember the big old Application Servers? 34. Is Node.js Worth The Hoopla? If you’ve gotten started programming with HTML and JavaScript (JS), you know how easy JS is to use. The interface is right at your fingertips. You can easily access your entire web page with simple commands. 35. Node-RED Configuration Explained In 600 Words Quickly get up and running with an advanced Node-RED Server. 36. NodeJS: Code Execution Monitoring With Inspector Have you ever desired to watch your code running, instead of just imagining it? 37. Deno🦕 - Is it a threat to Node? Deno 1.0 is launched on 13th May 2020 by Ryan Dahl — the original creator of Node.js 38. Building Your First Node-RED Flow: Basic Tutorial This post introduces a deep dive video tutorial where I teach you the fundamentals of Node-RED and at the same time, show you how to build a Weather dash 39. Building A Twitter Bot With Node.js - Part 2: Deploying to Server and Schedule Tweets In part 1, we learned how to create a simple Twitter bot with Node.js. In this article, we will go over how to deploy the bot and schedule tweets 40. Why use Node.js as your backend? Do you have an innovative idea that’s going to turn your web app into the next big thing? That’s great - but remember that software development is a process that has to be well-thought-out, and the most critical decision of what backend environment are you going to choose has to be made at the early beginning. 41. 🎉 Deno: 1.0: A Review of Features [We're Going Live] 🤠 Introduction 42. How to Manage Multithreaded Node JS Applications for Better Performance In this post I'm going to show you how to potentially triple your Node application's performance by managing multiple threads. 43. How to Build A Passwordless Authentication with Email and JWT In this quick article, you'll see how to prevent one of the OWASP Top 10 security issues for websites: authentication that hasn't been implemented correctly. 44. Final Bot Pre-Launch & Initial HN 2.0 Post! Hi folks! 45. Let's Build It: Real-time Session Invalidation How would we build an experience like the one above? Demo Repo Some applications need to limit users to a single client or browser instance. This post covers how to build, improve, and scale this feature. We begin with a simple web app with two API endpoints: 46. How To Create a Custom Webhook URL Using Autocode TLDR (30s) 47. 10 Common Sense Definitions of the Most Common Crypto Industry Terms “The limits of my language are the limits of my world.” 48. Top 10 Best Web Scraper And Data Scraping Tools Data extraction has many forms and can be complicated. From Preventing your IP from getting banned to bypassing the captchas, to parsing the source correctly, headerless chrome for javascript rendering, data cleaning, and then generating the data in a usable format, there is a lot of effort that goes in. I have been scraping data from the web for over 8 years. We used web scraping for tracking the prices of other hotel booking vendors. So, when our competitor lowers his prices we get a notification to lower our prices to from our cron web scrapers. 49. 6 Ways A Node Developer Can Drastically Boost Their Productivity These six productivity tips will supercharge your productivity as a Node developer. You'll save hours of time which you can then invest in other activities. 50. Rendering Markdown Pages with Express and Los Angeles Node and Express are great for building dynamic websites but often you'll also have some static content too. While its reasonably easy to author these pages in straight HTML a better option for this kind of content is often Markdown. 51. How to Add Knex to ExpressJS Apps and Connect to a Postgres Database Express is one of the most popular JavaScript frameworks for building backend APIs and Postgres is a really popular relational database. How do we connect them? 52. Skip the SSL w/ Serverless Telegram Bot via Now.js Note: these directions come without much conversation, let the hacking begin! 53. Basic Guide To Building Microservices With MongoDB, NodeJs, And Express Most of us have gone through tough times where you have a large scale application which has a bunch of features, API integrations, database connections, etc. New features and updates get released, and of course you need to fix the bugs and maintain the code. 54. How to Send and Schedule E-mails via a Node.js app As an application developer, how often we sense the need of a service that would send e-mails to specified or subscribed email ids? Even if there is no real need, we still fantasize about it while developing a pet-project or an app for fun, don't we 😁? 55. The Seven Best Admin Templates And Themes in React The appearance of Node.js became the new era for JavaScript because of the opportunity to synchronize frontend and backend. All JavaScript programs with help of 56. What Heroku is Good For You've probably heard about Heroku by now, but do you really know how Heroku works and when it should be a consideration? 57. Understanding the Node.js Event Loop JavaScript is single-threaded, so how does it handle asynchronous code without blocking the main thread while it waits for an action to complete? 58. Setting up a Serverless Contact form in React — using Nodemailer and Express Having a contact form always works better than just displaying an email address on our website. A contact form gives our visitors an easy way to get in touch with us. 59. HarperDB - How and Why We Built It From The Ground Up on NodeJS The founding team at HarperDB built the first and only database written in Node.js. Here's the story of this (what some called crazy) endeavor. 60. Delivering Static Web Content on Heroku [A How-To Guide] My primary goal is to find a solution that allows my limited time to be focused on providing business solutions instead of getting up to speed with DevOps processes. 61. How to Reset Password with Node.js and Angular [Part 2] In this 2nd part of our tutorial, we are going to continue our journey of creating reset password functionality. In the 1st part, we completed the back-end with Node.js Express and Node mailer, created an API which will use in this part in Angular. Let’s get started. 62. Node.js Inject: How to Conduct and Why to Use Today, I would like to show you how to execute custom JS code in another Node.js process and to get a proper result. These are relatively simple code examples, which demonstrate basic ideas of native code calls with the help of Frida framework. 63. 14 Top Node.js Open Source Projects: 2021 Edition Note that under open source projects we assume the following: 64. JavaScript Promises, Callbacks, and Async/Await for Beginners ES6 came with many new features, but one of the best features was the official introduction of Promises. Promises allow you to write clean non-callback-centric code without ever having to worry about callback hell. Even if you never write your own promise, knowing how they work is incredibly important, since many newer parts of the JavaScript API use promises instead of callbacks. The core idea behind promises is that a promise represents the result of an asynchronous operation. 65. Build Your Next eCommerce Store on NodeJS Top easiest ways to make an eCommerce store with Node.js. Shopify vs. buit-for-you solution. 66. Deep Dive Into Creating Node Project With Clean Architecture (Photo by Bench Accounting on Unsplash) 67. How to Create a RESTful API With HarperDB and FastifyJS Learn how to build a course management REST API with Node.js, HarperDB and FastifyJS. Thank you for checking out the 67 most read stories about Node on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

67 Stories To Learn About Node

Let's learn about via these 70 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Mongodb /Learn Repo 1. Let's Make An API And Sell It APIs are in high demand. Making an API that companies want to use would be even better if you could sell it, too. This is how to do it with every step inside. 2. MongoDB 101: A Free Course By Academy 3T MongoDB is a document-based NoSQL database, typically used for its ability to quickly scale, especially large amounts of data. MongoDB has two clear main benefits over SQL when it comes to data organization: 3. Get Started Building your First MERN Application - Step by Step I am sure that when you first begin learning full-stack web development using the MERN stack, you will have questions. 4. MongoDB vs. DynamoDB: Choosing the Best Database for Your Business All about MongoDB vs DynamoDB. Explore benefits, and in-depth comparison to find out the best choice for your business app. 5. MongoDB vs. DocumentDB: Which Is A Better Choice for You? Are you trying to decide if you should use MongoDB or DocumentDB? With the recent controversy surrounding licensing with MongoDB, it can be confusing to decide which option is right for your company or project. Amazon decided the core MongoDB code is challenging to scale while remaining highly available. Amazon wrote their implementation, which is compatible with the Apache 2.0 open source MongoDB 3.6 API. MongoDB, Inc. has also recently changed their license to make future imitations more difficult. To do this, they created an entirely new license called the Server Side Public License. 6. I made AWS Lose Money - Here's How! This is a short series that I wanted to share for a long time about the basics of “Cost Optimization” on AWS. 7. 8 Tools You Can Use to Analyze Big Data An essential part of modern business, no matter what the industry, is Big Data - sets of copious amounts of data that reveal much in terms of trends and patterns regarding human behavior and interaction. 8. Homebrew - Explained in Simple English So, there are tonnes of jargon, commands, processes that we follow blindly after surfing from the internet without knowing the actual reasons and under the hood processes, that just remain in our short term memory and get purged eventually, thus we don't feel comfortable using or even about discussing in a group about them. 9. Enabling Virtuals In Mongoose Lean Mode (in a FeathersJs service) Originally published at melvinkoh.me 10. How to Erase Expired Docs Automatically with MongoDB (TTL index) Recently I needed to delete some documents that I saved in MongoDB after some time. I can think of a few examples of why we would want to delete data after some time: 11. How I Built a Warehouse Management App Called Cardus A web app that allows users to create and manage their warehouse of items. 12. How to Use .populate() With mongoDB How to use populate() method with mongoDB to itch data across referenced collections 13. Mastering MongoDB - one tip a day series 14. Uploading a 1 Million Row CSV File to the Backend in 10 Seconds Uploading 1 million row size large CSV to mongoDB using nodejs stream 15. How to Find Insecure MongoDB Connection Strings in Public GitHub Repositories A guide on how to protect yourself and your projects while on Github. 16. MongoDB: Exploring Data Visualization Tools and Techniques Looking for MongoDB data visualization tool? There are plenty of options but firstly its better to explore what kinds of solutions there are on the market. 17. Efficient Server Side Pagination using Mongodb How to implement server-side pagination in MongoDB using aggregation pipeline instead of client-side pagination and why you should do it server-side instead. 18. Best Tools For Building Your First MERN Application Top tools to use when building your next awesome web application using the MERN stack 19. Learning the basics of MongoDB by Writing a User Registration API Learning MongoDB has been one of the things in my checklist for the past 6 months but hasn’t gotten around actually learning it until now. In order to understand writing queries and all I figured it’ll be better to make something instead of just reading and watching some tutorials. So, I’ve decided to make a user registration API i.e, a simple registration form kinda thing with only sign up and sign in functions as of now. As learning Mongo was the main intention, I’ve decided just to make the core app which is the backend functionality and no front end as it’s not necessary and I hate to do it. 20. When ORMs Disobey: A Mongoose Story In hindsight, it seems like mongoose was doing the sensible thing by simply ensuring that the document existed in the database. 21. How To Create a URL Shortener using MongoDB And Node Let us learn about MongoDB, Mongoose, Node, and other tech by building a simple URL shortener project. 22. InfluxDB: From Open Source Time Series Database to Millions in Revenue The InfluxBD Origin Story: How Paul Dix took a failing SaaS product and turned it into a successful commercial open source time series database company. 23. Instant GraphQL + MongoDB Backend With Mongoke Implementing a good GraphQL backend to serve your database data is not an easy task, you have to implement a lot of resolvers, add authorization, pagination of the fields and use a DataLoader to not repeat your database queries during relations. 24. A Guide to Using MongoDB Database in a ASP NET Core Web API Application When you think about database providers for ASP NET Core apps, you probably think about Entity Framework Core (EF Core), which handles interacting with SQL databases. But what about the NoSQL options? A popular option for NoSQL is MongoDB. So in this article we're going to learn how to create a simple ASP NET Core CRUD API using MongoDB as the database provider. 25. How to Change Parameters of a Server at Runtime Implementation of business configuration provider tips. Java, Spring and MongoDB in action 26. Building a REST API in Go with MongoDB Integration: A Step-by-Step Guide Code or Write a REST API with GO internal libraries and MongoDB as database 27. Is MEAN Tech Stack the Best Choice for Enterprise Solutions? Get to know why the MEAN tech stack for enterprise solutions is the way to go about scalable, secure, and sustainable software for organizations. 28. Mastering MongoDB - currentOp “Dashboard in the pilot's cockpit” by Mitchel Boot on Unsplash 29. MEAN Stack Development: All That You Need To Know Web development is not the same it was in the early internet age. It is a fast-paced and diverse environment. With the continuous advancements in frameworks, programming languages and tools, it becomes difficult to choose the “right” tech to ensure rapid, accurate and secured web application development. 30. How to Create a Serverless API Using Azure Cosmos DB In this tutorial, we’ll build a Web API using Azure Functions that stores data in Azure Cosmos DB with MongoDB API in C# 31. Design for E-Commerce Apps Using a NoSQL Database Working with a lot of data like products, orders, categories, users and payments is a very important topic when building e-commerce applications. In this post you'll learn the very basics of structuring your noSQL schema so it's fast and scalable for e-commerce scenarios. 32. 2019 Database Trends – SQL vs. NoSQL, Top Databases, Single vs. Multiple Database Use Wondering which databases are trending in 2019? We asked hundreds of developers, engineers, software architects, dev teams, and IT leaders at DeveloperWeek to discover the current NoSQL vs. SQL usage, most popular databases, important metrics to track, and their most time-consuming database management tasks. Get the latest insights on MySQL, MongoDB, PostgreSQL, Redis, and many others to see which database management systems are most favored this year. 33. AvionDB: A MongoDB-like Distributed Database In the past few months we have been getting this question a lot: 34. A Brief Introduction to MongoDB MongoDB is a document-oriented NoSQL database for storing large amounts of data. MongoDB uses collections and documents instead of tables and rows 35. A DIY Guide to Building an Analytics Dashboard with Node, Express, and Cube.js In the following tutorial, I’ll show you how to create a basic analytics dashboard with Node, Express, and Cube.js. As a database, we’re going to use MongoDB with MongoDB BI Connector. If you’re not familiar with it, I highly recommend you go through the Building a MongoDB Dashboard tutorial. It covers the basics of setting up Mongo and its BI Connector. 36. Learnings From The Meow Bot Attack on Our MongoDB Databases and ever since then we never look at a kitty the same way again. meow! 37. How I build Coronavirus Tracking Application What is Coronavirus (COVID-19)? Coronavirus (COVID-19) which is an infectious disease caused by respiratory illness and symptoms like flu, cough, fever, difficulty breathing, on December 31, 2019, the first case was recorded in Wuhan, China and later the virus got spread around the world and as of now, around 1 million+ confirmed cases are being recorded since then. You can protect yourself from this virus by following basic precautions like washing your hand frequently, avoid touching your face, maintaining a distance of (1 meter or 3 feet) between people and most importantly if you are sick then immediately call for medical help at your nearest hospital. 38. AvionDB Introduction: A MongoDB-like Distributed Database In the past few months we have been getting this question a lot: 39. Which Database Is Right For You? HarperDB vs. MongoDB vs. PostgreSQL The purpose of this article is not to determine which database is the best but to help determine which is a fit for your specific project. 40. Top 3 Databases Every New Developer Should Know Most new developers wonder which database is suitable for their project since they don't want to get off on the wrong foot. So, first and foremost, let's define a database. A database is a type of storage facility that electronically stores and organizes data so that it may be utilized and accessed later. 41. NoSQL: A Brief History and the DynamoDB Challenge Dynamo accelerated the NoSQL revolution that’s driving the database industry. 42. The Pros and Cons of NoSQL Learn how NoSQL differs from SQL and how it's built for high performance and availability. And no, it doesn't stand for "No SQL". 43. SQL Databases Vs. NOSQL Databases The decision to choose a database  for project is not that simple. But when it comes to choosing a database, the biggest decisions is picking a relational (SQL) or non-relational (NoSQL) data structure. 44. “I Want to Make my Own Netflix!” — So I Become a Software Developer Growing up, I had an interest in learning and always dreamed of creating my own software. 45. The Ultimate Guide To Custom Role Based Access Without Third Party Libraries Here, we have four roles: Sme, Sponsor, Admin, Operations.Initially, we had only 3 roles.Operations role was added later and Operations user has permissions similar to the Admin user.In the code, we had to replace every instance of if (user.type == USER_TYPES.ADMIN) with if (user.type == USER_TYPES.ADMIN || user.type == USER_TYPES.OPERATIONS).As this is time consuming and we can also miss many instances, we have created a roles module. In the roles module,the roles are defined along with their respective permissions as seen in Code (Part-III). Based on the permissions for each role, we will evaluate the authorization for the user in each of our controller methods.If the user has access, only then he will be granted the resources. 46. How to Reset Password with Node.js and Angular [Part 1] There are lots of tutorials about user authentication but all of them are just covering the topics like how to sign up and how to sign in. Even if you find a tutorial about reset password then you will see that it covers old school method without APIs and using jQuery based front-end. In this tutorial, we are going to use a Node.js based API which will connect to Angular front-end. Let’s get started: 47. How to Stream XML messages from IBM MQ into Kafka into MongoDB Let’s imagine we have XML data on a queue in IBM MQ, and we want to ingest it into Kafka to then use downstream, perhaps in an application or maybe to stream to a NoSQL store like MongoDB. 48. Improving Our MongoDB Write Throughput with SQS Deep dive on how we got our MongoDB load at a steady sub 50% CPU load by using an SQS layer between our Node application and the database to save costs. 49. How to Run Node.js with MongoDB [Tutorial] Many of today’s web applications use node.js in conjunction with MongoDB to store and access data on the backend server. Not only does node.js excel in ease of access to non-relational databases like MongoDB, but brings scalability and speed to the server side of your app. 50. How to Connect MongoDB(4.2.10) and MongoDB Compass Locally What is MongoDB? 51. Breaking Down MSON Template Queries Template Queries are dynamic templates constructed with MongoDB-style operators, which allow you to customize MSON components with less code. 52. Augh, Someone deleted production data. “A man stretching out his two hands with careless written on them in black and white” by Mitchel Lensink on Unsplash 53. One-Time Password Generation Using speakeasy, Nest.js And MongoDB Here, we have designed and developed a flow for OTP(One time password) for user registration and also blocking a user's account after the maximum retries for incorrect otp is exceeded. 54. Get a GraphQL server up and running in 5 minutes using graphql-yoga and mongoose THIS ARTICLE IS NO LONGER UP TO DATE. USE APOLLO SERVER INSTEAD. 55. Solving invisible scaling issues with Serverless and MongoDB Ever since software engineering became a profession, we have been trying to serve users all around the globe. With this comes the issue of scaling and how to solve it. Many times these thoughts of scaling up our software to unimaginable extents are premature and unnecessary. 56. Building a MongoDB NoSQL E-Commerce Data Model MongoDB supports ACID transactions, and its cloud offering is PCI DSS compliant. It's one of the best NoSQL options for e-commerce. 57. How To Link Mongoose And Typescript for a Single Source of Truth Without external tools 58. Advanced and Efficient MongoDB Pagination How to make clean pagination with no additional dependencies. Basically for Node.js but can be used in any other languages and platforms. 59. Creating a Object Storage System from scratch I was very much interested in developing distributed systems and the like. But it was very difficult to find related beginner articles. One of my projects was a cloud drive. In order to implement that, i had to go many places i haven't. It had a good steep learning curve.  I wanted to share that knowledge. 60. PostgreSQL vs. MongoDB: Evaluating Database Structure, Speed, and More Choosing a database can be scary as it’s nearly impossible to change once you’ve built on one. So which will you choose? PostgreSQL or MongoDB? 61. Getting started with MongoDB Enterprise Operator for Kubernetes Introduction 62. Building User Service With GRPC, Node.JS, and MongoDB: The Complete Microservice Tutorial — [Part 2] Microservices are about decoupling your system. In a monolith, you build all the components of the software in one large codebase and deploy the software at once. But in the microservice world, we build each component of a large system decoupled from each other. 63. How to Build A Well Structured 3-tier Architecture (MERN Stack - ES6) [Step-by-Step Guide] This project serves as a guide/template for a 3-tier architecture. If you are entirely new to Web Development. I highly suggest you watch this video first. 64. Basic Guide To Building Microservices With MongoDB, NodeJs, And Express Most of us have gone through tough times where you have a large scale application which has a bunch of features, API integrations, database connections, etc. New features and updates get released, and of course you need to fix the bugs and maintain the code. 65. Mastering MongoDB - Introducing multi-document transactions  in v4.0 Photo by Madison Grooms on Unsplash 66. Why We Should Have Different Databases Today there are hundreds of SQL and NoSQL databases. Some of them are popular, some are ignored. Some are user-friendly and well documented and some are hard to use. Some are open sourced and some are proprietary. And, perhaps, the most important - some are scalable, optimized, highly available and some are difficult to scale or maintain. 67. How to Back Up and Restore a MongoDB Database MongoDB. Seven Ways to Back Up and Restore Data 68. Mastering MongoDB - Faster elections during rolling maintenance Photo by annie bolin on Unsplash 69. Configure MongoDB with Kerberos Authentication The MongoDB database administrators in a large enterprise may need to configure MongoDB to support Kerberos Authentication. The configuration of MongoDB with Kerberos authentication is very simple, provided you have some Kerberos knowledge. The MongoDB documentation article, Configure MongoDB with Kerberos Authentication on Linux, is pretty extensive on this topic. However, the article states — “Setting up and configuring a Kerberos deployment is beyond the scope of this document”, resulting in some of the starters/enthusiasts with limited knowledge in Kerberos not proceed any further. This article is geared more towards bridging that gap and to help you understand 70. A Complete Guide to Laravel Sail This post is about what to expect from Laravel Sail, how it works and how to make the most of it; it is also a plea to developers to break away from it. Thank you for checking out the 70 most read stories about Mongodb on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

70 Stories To Learn About Mongodb

Let's learn about via these 57 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Json /Learn Repo 1. Creating Developer-Friendly Data Services with Apache Cassandra Using data APIs and advanced data modeling will make it far easier for JSON-oriented developers to connect to Apache Cassandra. 2. Introducing Yet Another JWT Debugger Introducing a new JWT Debugger App - our way to contribute back to the developer community. The app is available on the web and as Desktop apps for Windows, Linux, and Mac. With JWT Debugger App we immediately highlight what really matters to you as a developer without any shenanigans. It is a very simple tool but we hope it will improve the developer experience. 3. How to Use .populate() With mongoDB How to use populate() method with mongoDB to itch data across referenced collections 4. How to Query Deeply Nested JSON Data in PSQL Recently I had to write a script, which should’ve changed some JSON data structure in a PSQL database. Here are some tricks I learned along the way. 5. How to Export Your HackerNoon Stories as a PDF The HackerNoon team is back at it with a new feature! You can now export your stories to a PDF or a JSON file. 6. The History of JSON and the People That Created It Douglas Crockford and Chip Morngingstar created the data exchange format that is now known as JSON. 7. Automate Simply With Webhook Automate anything with Webhook, a simple tool for your toolbox 8. With JSONB Data in PostgreSQL, You Can Get the Best of Both Worlds JSONB in PostgreSQL offers the best of relational and NoSQL. Here are two techniques that we use at AppLand to make JSONB data even more effective. 9. Custom Log Processor Integration – Fluentd vs Vector.dev By writing your tool, you gain more customization options, versatility, and other enhanced capabilities that can enrich your processing. 10. Defining Types: Using allOf in Swagger JSON Image by Devanath from Pixabay 11. 7 Kotlin Libraries Every Developer Should Know The most common Kotlin libraries that are used for cross-platform and Android development, testing, and documentation are considered in the article. 12. So, How are Observability and Monitoring Different, Actually? The similarities and differences between monitoring and observability and how to pair the two strategies 13. Ruby: How to read/write JSON File In Ruby read and write JSON file to hash can be achieved using File Handling. 14. How To Extract Key or Value From Hash in Ruby on Rails When I was recently working in one of the client projects, I had to
communicate with external MariaDB server to store records from
React/Rails app, that means I would get ActiveRecord hash from our app
which I had to convert to pure SQL query and send it to an external
server for storing. 15. A Quick Primer on Data Scraping Suppose you want to get large amounts of information from a website as quickly as possible. How can this be done? 16. Streamlining Form Validation with JSON Schema for Front-End and Back-End Efficiently validate forms with a single set of rules for both front-end and back-end using JSON Schema. 17. The Complete Microservice Tutorial: Introduction [Part 1] Project Link: https://github.com/Joker666/microservice-demo/ 18. An Interview with the Creator of JSON Douglas Crockford We had a nice chat with Douglas Crockford, a well-known American computer programmer who was involved in the development of the JavaScript language. 19. JSON Web Token: How To Secure Your Data With JWT A JSON Web Token (JWT) is an open standard (RFC 7519) that defines a way for securely transferring information between two parties. It can be used for an authentication system. As this information is digitally signed, it can be verified and trusted. 20. 8 Tips for Solving The JSON RPC Error In Metamask The most problem users come across is the internal JSON RPC error in Metamask. After a detailed search, I found there are numerous different solutions to it. 21. Hybrid Data Models: How To Have Your JSON Cake and Eat MariaDB Too By adding support for JSON, MariaDB provides the ultimate schema flexibility without sacrificing transactions or data integrity. 22. How To Do Data Mapping in Kumologica Data mapping is a key element in integration. Most of the prominent integration tools provide different capabilities for data mapping. In this article I thought of sharing on how data mapping can be achieved in Kumologica. Kumologica uses JSONata as the base for data mapping. JSONata is a Lightweight query and transformation language for JSON data. It supports complex queries expression which can be achieved with minimal syntax and has a location path semantics of Xpath 3.1. 23. How to Encode and Decode JSON with Scala-Circe Getting started with encoding and decoding JSON using Scala-Circe. 24. When Json Serializations Go Horribly Wrong From DateTime serialization issues, to the fact that serializing DateTime.MinValue causes a crash, because UTC time is less than minimal allowed DateTime value. 25. Fetch Data From a JSON File With a React & Redux App This guide explains how to use React and Redux to fetch data from JSON files in an easy and lightweight method through a real example and well explained steps. 26. Parsing JSON in C with Vely framework Parse JSON in C language with Vely framework 27. How to Use Data Science to Find the Best Seat in the Cinema (Part I) From the most popular seats to the most popular viewing times, we wanted to find out more about the movie trends in Singapore . So we created PopcornData — a website to get a glimpse of Singapore’s Movie trends — by scraping data, finding interesting insights, and visualizing them. 28. How To Query JSON in Couchbase via Collections and Scopes This week I’m attending the 3-day Couchbase Connect event and will be reporting on some of the topics that I find most interesting. 29. Extracting Information From Hash in Ruby on Rails When I was recently working in one of the client project, I had to communicate with external mariadb server to store records from react/rails app, that means I would get activerecord hash from our app which I had to convert to pure sql query and send it to external server for storing. If you have worked with sql queries previously then you must know that keys and values must be separated for insert operations like 30. Logging Vs. Monitoring: Best Practices for Logging [Part 2] Logging and Monitoring… this I tell you, brother. You can't have one without the other. 31. The Best Java Libraries that Every Developer Should Know This article describes Java libraries like Apache Commons, Guava, Log4j2, Logback, SLF4J, JUnit, TestNG, Mockito, Hamcrest, AssertJ, Jackson, Gson, JAXB, StAX 32. A Quick Guide to JSON Web Token [JWT] JSON Web Token (JWT) is an open standard (RFC 7519) for securely transmitting information between parties as JSON objects. 33. Improve Network API Performance For Your Apps Network APIs are everywhere in the modern world. If the data is the lifeblood of modern tech, then APIs are essentially vessels that carry it around distributed 34. Back-end Data and API Prototyping with Faker.js and JSON-Server Introduction 35. How to use Recursion to Traverse JSON Objects and the Filesystem I work primarily on application-level programs, so I tend to not use recursion very often. However, every now and then I need a function that is best solved recursively. It is important to be able to recognize when a problem is best solved recursively, and to be able to write it when the time comes. 36. Breaking Down MSON Template Queries Template Queries are dynamic templates constructed with MongoDB-style operators, which allow you to customize MSON components with less code. 37. Tree - AST Crushes JSON, XML, YAML, TOML, etc XML, JSON, TOML, YAML are bad relative to Tree data format 38. Debugging Gson, Moshi and Jackson JSON Frameworks in Production Parsing is a major source of production failures. Some are easy to track but some are insidious. Here's how you can debug them on the fly! 39. µjson — A minimal JSON parser and transformer in Go µjson is a minimal JSON parser and transformer that works on unstructured (and trusted) JSON. It works by parsing input and calling the given callback function when encountering each item. 40. Build Data-Driven Web App Without Backend During the last couple of decades websites' functionally has increased dramatically - from simple landing pages serving simple static ads to complex progressive web apps whose functionality close to native applications including user authorization, location tracking, bluetooth handling, and offline mode. 41. Using JSON Mapping to Work with APIs of Various Image Services Using JSON Mapping to Work with APIs of Various Image Services. This approach is applicable to any other services that are similar in type of returned results. 42. Coding 101: Who is Json? A.) Jason Voorhees (Friday the 13th) 43. Five Important Tips For Working With JWTs Nowadays, JSON Web Tokens are the most common way of proving identity information to APIs. The concepts behind JWTs are also quite easy to understand, and it takes only a couple of minutes to have the most basic authentication running. 44. Using Rainforest API With WordPress [A How-To Guide] Rainforest API is an alternative to the Amazon Product API provided to Amazon Associates. If you are thiking of building shopping comparisson sites with Amazon links and you don’t have an API key, or if you want to build a lot of pages very quickly without limitation, using Rainforest API is the answer. If you are serious about earning money as an Amazon Affiliate and want to make thousands of pages, do yourself a favor and start the project off right. 45. Writing Your First REST API: A How-to Guide As part of my Borum Jot project, I made a Web API for all my front-end platforms to create, retrieve, update, and delete (CRUD) data on the database. In this article, I'll discuss what exactly an API is and how I made my own Web API. 46. Today I Learned: Dealing with JSON DateTime when Unmarshal in Golang. Beware the date-time standard!! 47. What is SQL? And Where is it Used? What is SQL? Databases use it, query APIs use it, even energetic big data dashboards use it! Where did it come from and how are developers, DBAs, and app using. 48. Introducing Jdict Module in Python Providing attribute access to Python dictionary entries 49. 8 Most Popular Weather APIs for 2020 The climate is a hot issue and weather forecasting technology is suddenly cool. The urgent need for innovative weather and environmental conditions forecasting solutions is obvious whether you believe in climate change or not. 50. How to Win the Velo Writing Contest: A Detailed Cheat Sheet In order to display a non-static website - you'll need to have a data source and connect it with Velo. For example, you can create some sort of "fake API". 51. 3 Best Ways To Import JSON To Google Sheets [Ultimate Guide] 3 ways to pull JSON data into a Google Spreadsheet 52. How To Create a Simple Autocomplete Field And Connect it With Elasticsearch Autocomplete is a feature to predict the rest of a word a user is typing. It is an important feature to implement that can improve the user’s experience of your product. 53. How I'm Engineering a Versioned Database Storage Engine for Byte-Addressable NVM Feel free to contribute on GitHub 💚 54. JSON Web Auth Using Angular 8 and NodeJS The article is about interfacing an Angular 8 Project with a secure backend API. The Backend will be running on Node.JS. The security that will underlay the interfacing will be JSON Web Tokens. 55. Go: Handling JSON in MySQL 56. Querying Complex JSON Objects With SQL How many times have you run into a situation where you wish you could do a SQL join without getting duplicate rows back? What if we could get a list "column" returned instead? HarperDB’s ARRAY() function enables just that. In this post we’re going to take a look at a basic example of people with addresses and phone numbers. 57. Document Databases vs Relational Databases (Podcast Transcript) Amy Tom talks to Eric Bishard and Arun Vijayaraghavan about the differences between a Document Database and a Relational Database. Thank you for checking out the 57 most read stories about Json on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

HarperDB News on
HackerNoon and Around the Web

Winner for Best Startup in Denver, Colorado!

harperdb.io

31 employees

Since 2017

HarperDB Story Mentions

Articles Around the Web

Read More Tech Stories Related to #HarperDB

HarperDB News on HackerNoon and Around the Web