Forem: JoeTags

Let's Go!

JoeTags — Mon, 08 Nov 2021 14:57:57 +0000

As I finish the last week of my software engineering bootcamp, it is time to start focusing my energy on the job hunt. One of the companies I’m interested in working with lists a particular technology as a Nice to have’. So, this week, I decided to write my blog on golang, the Go language. Let the endless journey of learning continue.

The Go language was developed by computer scientists Robert Griesemer, Rob Pike, and Ken Thompson at Google and released in 2009. The mission was to address deficiencies in other programming languages used at Google. A few issues the trio sought to address was to create a language that was easy for a programmer to use. That meant having a minimal set of strict rules. They also wanted a language that would compile quickly and could scale to large codebases that had large teams of developers. Later in the article, we will get into some of the more technical details but first let’s get a better understanding of what makes Go unique.

If you head over to golang.com, the mission statement for the language reads:

“The Go programming language is an open-source project to make programmers more productive.

Go is expressive, concise, clean, and efficient. Its concurrency mechanisms make it easy to write programs that get the most out of multicore and networked machines, while its novel type system enables flexible and modular program construction. Go compiles quickly to machine code yet has the convenience of garbage collection and the power of run-time reflection. It's a fast, statically typed, compiled language that feels like a dynamically typed, interpreted language.”(golang.org)

Let’s break this down because if we can’t understand what the language is doing in plain English its going to be very difficult to learn how it codes.

The first sentence is pretty self-explanatory and we touched on this earlier that the language was designed to be concise, easy to read, and easy for programmers to remember all of the rules.
Now the next sentence gets a little tricky.

concurrency and multicore, networked machines

I think the best analogy I can give for concurrency is to think of a symphony with a conductor. The conductor is concurrency and the different instruments are part of the program or computing system that need to execute. Some processes may need to happen at the same time and some out of order(asynchronous) and they need to be able to enact an exchange of data without hitting a deadlock.

When we talk about multicore, networked machines, we are talking about multiple CPUs interacting within a computing system(s) and the programs that are being run on these systems.

while its novel type system enables flexible and modular program construction.

The type system is a way of assigning a datatype to a language construct to ensure that the resulting value is in fact what is expected. In this way, it speeds up the compiling of the language and allows for fewer errors from the programmer.

“The main purpose of a type system is to reduce possibilities for bugs in computer programs[2] by defining interfaces between different parts of a computer program, and then checking that the parts have been connected in a consistent way. This checking can happen statically (at compile time), dynamically (at run time), or as a combination of both”. Type System.Wikipedia.Wikimedia Foundation.18 October 2021.06 November 2021.https://en.wikipedia.org/wiki/Type_system#STATIC

This sounds a lot like Typescript. And it is. If Typescript is Javascript with a type system. Then Go, is like C with a type system.

Touching on the last part of the Go language mission is its use of garbage collection which most compilers have anyway but the Go version is much more robust. In essence, it can detect whether or not import statements are being used within a program and remove them if not being used. Think about how much memory space that can save! Think of how much more efficiently a program can run if each file doesn’t need to import data and then the compiler doesn’t have to scan over that data. Incredible.

For a more in-depth analysis of the differences between Go and Typescript, check out Amit Belazel’s Medium article, Micro-service Languages: Typescript vs. Go.

Alright already! Let’s see some code

To begin, navigate to the getting started tab on the Go website and download the latest version of Go. It’s super, easy to setup and took less than five minutes. After that completes, you can begin to code in your terminal of choice. I used VsCode but you should check to make sure your terminal is compatible.

There are instructions in the tutorials section that can guide you on how to set up your first Go directory. Now, we can have some fun!

After you you initialize your directory and cd into a file. You can create a file with .go.

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Now, in the command line, type: go run . and voila! You have successfully created your first Go program.

So, now that you’ve had the lecture and have a more general understanding of what makes Go tick. Get out there and give it a try for yourself.

Buyer Beware!

JoeTags — Mon, 01 Nov 2021 13:19:01 +0000

(This is not a Halloween Story.)

We all rely on libraries to help make our programming lives easier. However, not all libraries are created equal. Sometimes you need to learn the hard way that the library you’ve chosen just doesn’t have the capabilities necessary for your desired end case. Maybe the real answer is a little vanilla Javascript.

I was recently working on a project and wanted to throw in some graphs to display user information from the database. It seemed like an easy enough task. I had already written the logic for my API calls. All I needed, now, was a way to display the information.

I had never used a graph in a project and decided to try Charts.js. I’m not sure if someone recommended it to me or if I found it on my own. So, like, with any new library I went to the documentation to learn how to implement a chart. It was a clean site with seemingly good docs. They had some examples linked up and it was compatible with React. I copy and pasted a tester not related to my code to see if it would render. It rendered. All good, I thought.

This is where the trouble began.

The issue I kept having while trying to implement a Doughnut chart was that I could not pass dynamic data into the chart. Hardcoded data worked fine. Was this a Promises issue? Most likely. I attempted to conditionally render the hardcoded data until my dynamic data loaded and then update the state. Again, no luck. After wrestling with this for a over a day, I had a decision to make.

Do I change routes and use a new library or keep trying and testing? I had a Monday deadline and each hour that passed was valuable.

In the end, I chose to change paths and used react-google-charts. It was very Googly. Little style but excellent functionality. I had my chart rendering with all my data in under an hour!

import { Chart } from 'react-google-charts';
const countObj = {};
const Charts = ({ poses }) => {

 const countObj = (poses.map(pose => pose.difficulty)).reduce((prev, curr) => (prev[curr] = ++prev[curr] || 1, prev), {});


        let level = Object.entries(countObj);
        let count = Object.values(countObj);
        let output = ['Difficulty', 'Number of Moves'];

return (

  <div>
    <Chart
    width={'420px'}
    height={'420px'}
    chartType="PieChart"
    loader={<div>Loading Chart</div>}
    data={[
      ['Difficulty', 'Number of Moves'],
     ...level


    ]}
    options={{
      title: 'Degree of Yoga Poses',
    }}
  />

  </div>

)

  };

Sometimes what we don’t know through a lack of experience can be one of our biggest obstacles in programming. I could have saved myself an entire day had I just switched chart libraries sooner. But, then I wouldn’t have learned about the difficulties of using Charts.js with dynamic data. Also, I would have learned less about why charting data is so fussy. And why it’s a great exercise to attempt to improve your asynchronous coding. One of the major issues you will face is breaking the page because your data has not loaded before it gets called in the call stack. In order, to prevent this from happening you will need to have some conditional rendering while the Promise is waiting to be returned.

It’s not that I won’t keep working to figure out how to properly render a chart with Charts.js. But, it is an issue when making use of a library and not fully understanding what is happening behind the scenes. It’s much harder to troubleshoot an issue when you don’t know how the library functions.

A big red flag and one that I will follow in the future is that I couldn’t find a single working example of Charts.js being called with an API or passing props to load in dynamic values. At NPMJS.com, there were a handful of different chart examples at a Github link. However, none of these examples had dynamic data being passed. I should have stopped before I got to this point. Lesson learned, I guess.

It got me thinking, though. I spent countless hours re-implementing reduce, map and filter, so that, I could better understand how to use these functions while coding. Maybe I need to take some of the lessons I learned in my early bootcamp days and apply it to the libraries I seek to use. At the very least, I will learn what’s happening under the hood.

Postgres! What is it?

JoeTags — Mon, 25 Oct 2021 13:42:09 +0000

PostgresSQL is an open-source project that has become one of the most advanced database management systems in the world. It is a relational database system comprised of tables with unique keys and powered by the SQL command language. To better understand Postgres, it is important to have a fundamental understanding of relational databases, in general.

A relational database is one made of tables that are comprised of columns and rows. Each row is given a unique key allowing the user to access data specific to that key and utilize the properties that intersect at both row and column. Essentially, these tables are hash tables but its more accurate to describe the key or index as a hash index for that specific table.

Relational databases were invented in the 1970’s by E.F. Codd while he was working at I.B.M. and he developed a set of rules, known as Codd’s 12 rules, that define what constitutes a relational database. While it is not necessary to implement each rule in a functioning relational database, it illustrates the founding principles for how these data storage structures are built.

Now that we have some context on Postgres’ structure, let’s discuss the tools we use to make actions happen within the database. We’re talking about the SQL command language!

In Postgres inception, it was not used with SQL but a different command language known as QUEL but there was nothing cool about it. In 1995, the QUEL language and the monitor terminal associated with it were scrapped for SQL and the psql terminal.

SQL is a declarative programming language where a single command can be issued to access records in a database. It is based on relational algebra and tuple relational calculus. Luckily, the declarative style allows a user to type simple, intuitive commands.

For example, without knowing what this program executes…

const getEvents = () => {
  return new Promise((resolve, reject) => {
    db.query('SELECT * FROM events', (err, events) => {
      if (err) {
        return reject(err);
      }
      db.query('SELECT * FROM rsvps', (err, rsvps) => {
        events.forEach(event => {
          event.attendees = rsvps.filter(rsvp => {
            return event.id === rsvp.eventId;
          }).map(rsvp => rsvp.fullName);
        });
        resolve(events);
      });

    });
  });
};

We can get a general of sense of what is happening. SQL makes a selection from the database using the select all (*) wildcard. It reaches into the events table, getting all events then making a subsequent search into the RSVP table. It iterates through the events and finds the id’s that match the events foreign key id within the RSVP table.

This is an excellent display of the power and functionality of both the relational database and SQL command language.

So, what makes Postgres Postgres?

One of the main confusions I had when first working with Postgres was defining what set it apart from MySQL. It has many of the same commands and features and the terminals, though different, are similar enough. So, why should anyone use choose Postgres over MySQL.

I think the strongest selling point is going to be the implementation of object-oriented database functionality like that of MongoDb. An object-oriented database maintains a hierarchical relationship between database tables. As object-oriented programming makes use of inheritance patterns, it only makes sense that Postgres would establish the INHERIT keyword as its means of making this cross database utility feature.

Database Transactions

A transaction is an integral feature of any database. It combines multiple steps into a single ‘transaction’. It is an all or nothing type of commit that guarantees any update is permanently recorded to the database and possibly written to disk as well. Transactions are universal for relational databases but not common knowledge amongst inexperienced users.

Transactions are built upon ACID properties whereby data validity is guaranteed when these properties are upheld. ACID is an acronym for Atomicity, Consistency, Isolation, and Durability.

Atomicity describes the all-or-nothing bundling of steps that treat database queries as a whole. Several commands are bundled into a single transaction. Only when the entire transaction completes is any single step updated within the database.

Consistency is providing a set of rules and features that insist that a transaction is not corrupted. It does not guarantee the data itself but how the data is governed within the database.

Isolation is part of a larger relational database component known as concurrency control. This is where multiple transactions are executed simultaneously but the state of the transactions change as if they were happening sequentially. This is especially important for databases that hold finite sets of data.

Durability ensures that once a transaction is committed to the database it remains committed. This can be ensured as simply as writing the database to memory in the case of an outage.

Multiversion Concurrrency Control(MVCC) is a feature of Postgres that gives it an edge over MySQL’s performance. It allows multiple users to read data while others write data without hindering speed. Under the hood, each statement sees a snapshot of the previous state of the database to ensure the consistency of the current data being altered.

I hope this read helped to persuade you to give Postgres a try for your next project. Databases aren’t the most exciting feature of any website or application, but they are indispensable. If you don’t need a robust database MySQL should suffice. However, If you are going to be handling extreme amounts of data that changes on a daily basis, Postgres should be your choice.

Smart Contracts

JoeTags — Mon, 18 Oct 2021 13:53:19 +0000

What is a Smart Contract?

I’m writing to discuss smart contracts and their relationship with blockchain. This blog assumes that you have a general understanding of what a blockchain is and how it operates. If not, I ‘ve attached a link that provides a brief rundown. In addition, by the end of this read I’m going to help you learn how to write and deploy a contract using the oracle provider, Chainlink.

A basic definition of a smart contract is a computer program that exists on a blockchain and self-executes an agreement. However, if you go to Ethereum.org, you will find a more robust definition that outlines some of the key steps needed to build a smart contract.

An important one is that a smart contract is an actual Ethereum account. It has its own address where it resides on the blockchain and, in turn, has an ability to make financial transactions. So, not only will we write a smart contract but we’re going to deploy it to the Ethereum blockchain.

Smart contracts are immutable agreements or programs. Once it’s deployed and the code is executed it cannot be reversed. Some interesting use cases for smart contracts are lotteries, elections, or real estate transactions. In the last case, think of the blockchain as a notary public that bears witness and holds record of the smart contract.

One of the important features of a smart contract is that it takes real world data and attaches or binds it to the blockchain. In the use cases mentioned earlier, I provided examples of events or occurrences that can be added to the blockchain. But, this begs the question. If the data on a blockchain is immutable, and a smart contract, irreversible, how can we verify the data in a smart contract is legit?

Enter the Oracle. All hail the oracle. What the heck is an oracle?

An oracle is a way to send real world, verified data to execute a smart contract and potentially disperse money. It’s important to understand the concept of proof of work in blockchain mining to fully understand how oracles work. When someone makes a transaction on a blockchain, miners verify that the transaction is authentic before it is broadcast and entered into the ledger. It is the solution to the Byzantine General’s Problem and the ethos behind decentralization.

With oracles, it is the same procedure minus the hashing algorithm. Once a certain amount of people(nodes) verify that the data is correct, it can be passed along to the smart contract and blockchain.

In order to learn how to write a smart contract, I went to the Chanlink developers documention and followed a simple walkthrough for writing and deploying my first contract. Below is an example of a smart contract’s architecture. It’s slightly different than a typical class but follows the same convention. At the top, the Solidity language version must be declared. It’s followed by the contract keyword which is the equivalent of class in Javascript. It has a constructor which holds some state and a function written to execute some code.

pragma solidity 0.8.7;

contract sayHelloWorld {
    string public message;

    constructor(string memory initialMessage) {
        message = initialMessage;
    }

    function updateMessage(string memory newMessage) public {
        message = newMessage;
    }
}

If you follow the link above, you can learn how to do this in about fifteen minutes. First, you need to download the Metamask, software wallet. Then, you’ll need to fund it with some fake Ethereum or Chainlink. After that, you go to the Remix IDE where a premade contract to get price data for Ethereum is set to go. If you’ve built web applications before you’ll be familiar with compiling and deploying your code. However, it’s much easier with a smart contract because the code is minimal and doesn’t hold much complex data. Give it a try.

I Command Thee...

JoeTags — Mon, 11 Oct 2021 12:48:51 +0000

The Command Line

Can anyone tell me what day of the week Christopher Colombus landed in what is now the Bahamas? A quick Google search will tell you that he arrived on October 12th, 1492. But, it doesn’t mention the day of the week. The answer happens to be Friday. And, if you make it to the end of this article, I will show you how I used the command line to find out the answer.

In honor of Indigenous People’s Day, I figured I would use a little bit of history to teach you about a topic you’re probably not interested in. The command line interface.
So, what is and why should someone learn the command line? It seems dated, right? It pukes lines of noisy text that bother the eyes and confound the mind.

The command line is a powerful tool that can be used to interact with a computer’s operating system. It can access information in a computer’s file system. It can interact with an application’s database. It can make API calls(e.g. Git). In fact, it can do many of the tasks that a typical graphical user interface or GUI can do.

The command line interface(CLI) dates all the way back to the 60’s and was the primary means of communication between a person and a computer. As computers became more complex and PC’s became more widespread, the CLI evolved into computing tasks based on UNIX and eventually Linux-based distributions.

When we hear the words Unix and Linux, they typically refer to how software interacts with hardware. Otherwise known as kernels, Unix and Linux are the source of truth for operating systems. They define a set of standards and processes that make up the functionality of modern computing. Though they are similar, Linux is a clone of Unix, has different commands and is more geared towards an open-source community where ideas and technology can be shared freely.

When a user interacts with a kernel it is done through a shell. Some examples of shells are bash, zsh, powershell, COMMAND.com. Once the shell is entered, it opens with a terminal(CLI) which is a program that runs the shell. It displays a prompt which varies between different shells but typically will have the username and the hostname(computer name). At the prompt, it takes in a command. This is where the magic happens.

A command is made of several parts not all of which are required.

Command: what you are asking the program to execute
Options: specifications for your command to operate on the argument
Argument: the value for which the command is executing upon.

To answer my question from earlier I’m going to open up Ubuntu, which is a Linux distribution.

joetags@DESKTOP-R7QGGNP:~$ cal october 1492
    October 1492
Su Mo Tu We Th Fr Sa
    1  2  3  4  5  6
 7  8  9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30 31

joetags@DESKTOP-R7QGGNP:~$

The cal command prints a calendar in the console. The arguments passed in specify the month and the year for the command to print. If none were entered, it would print the current month and highlight the current day as well.

While this is basically a parlor trick for the true potential of the command line. If you have any Git experience you’re already aware of how you can transfer/update files to another server. Essentially, the command line can interact with the entire life cycle of your application. From initialization to deployment.
This article only scratches the surface of the command line’s potential. It gives a brief explanation of what it is and how it evolved. Hopefully, some of the concepts and terms discussed provided clarity and intrigue for an often overlooked tool. Happy coding!

All Board the Semiconductor Train!

JoeTags — Mon, 23 Aug 2021 13:52:51 +0000

Semiconductor Shortage: Oh, the places we’ll go!

Semiconductors are an integral part of the technological goals we face for the next decade and beyond. As we begin the early phases of breakthroughs in 5G, AR/VR, EV and the internet of things. It’s not hard to see why there has been much ado about the apparent crisis of semiconductor shortages.

What caused it?

The 2020 pandemic had unleashed no shortage of disruptions to life as we know it and one of those disruptions came in the form of semiconductor companies curtailing production as the uncertainty of the economic landscape and their client’s demand gave them pause.
A semiconductor is a microchip wafer made of silicon that is responsible for the computing power of a computer. It’s kind of like a computer’s brain.
Production of these small yet complex devices is incredibly complicated and expensive. It takes years of research to design the architecture of the chip itself. But, the manufacturing process is delicate and demanding. On average, it can take up to 26 weeks to get a finished product ready for delivery.

“semiconductor purity was not as big of an issue as it is today in device manufacturing. As devices become more integrated, cleanrooms must become even cleaner. Today, fabrication plants are pressurized with filtered air to remove even the smallest particles, which could come to rest on the wafers and contribute to defects. The ceilings of semiconductor cleanrooms have fan filter units (FFUs) at regular intervals to constantly replace and filter the air in the cleanroom; semiconductor capital equipment may also have their own FFUs. The FFUs, combined with raised floors with grills, help ensure a laminar air flow, to ensure that particles are immediately brought down to the floor and do not stay suspended in the air due to turbulence. The workers in a semiconductor fabrication facility are required to wear cleanroom suits to protect the devices from human contamination. To prevent oxidation and to increase yield, FOUPs and semiconductor capital equipment may have a hermetically sealed pure nitrogen environment with ISO class 1 level of dust.” (Semiconductor device fabrication, Wikipedia, August 4, 2021, https://en.wikipedia.org/wiki/Semiconductor_device_fabricati, par 4)

So the idea of a shortage may be a bit misleading or at least overblown. The recent news that the federal government is looking to subsidize the production of semiconductors in the U.S. to decrease the reliance on foreign companies is both arrogant and nationalistic. According to the semiconductor industry association, semiconductors are the #1 electronic export in the U.S. as well as the 3rd largest export behind planes and automobiles. Falun Yinug(2015, August). Made In America: The Facts about Semiconductor Manufacturing. Semiconductor Industry Association. SIA-White-Paper-Made-in-America.pdf (semiconductors.org).
This is not to say that the U.S. semiconductor manufacturing industry should rest on its laurels. Now, more than ever, it is high to time to push technological innovation.
Google, Apple, Amazon and Tesla have been working for years to design their own semis in house. This is not necessarily to address a shortage in semiconductors. They are all looking to capitalize on a huge market that’s still in its early days.
Of the three mentioned all have a legitimate shot at executing their ambitions with Apple already having proven so with its M1 chip design. As for Tesla, I’m not sure. They are still a newcomer to automotive industry and they lack the deep cash reserves of the companies just mentioned. Not only will Tesla have to compete with the best automakers in the world but they will also need to compete with the best chipmakers in the world. Add to that, it ‘dipping its toes in every market’ approach of space exploration, tunnel-digging, solar roof-making, and now laughingly robot- making. Click here for guffaw. And that could be biting off more than it could chew.

In addition to design innovation, there are companies leading manufacturing innovation as well.
Enter Atomera and mears-silicon technology. They developed a form of crystallized silicon that is applied, in layman’s terms, like a sticker over an existing microchip. This crystallized silicon helps to create a current flow for excessive heat to flow out from one side of the chip to the other. This is a problem that has plagued semiconductor manufacturers for quite some time as they try to decrease the die size of the microchip nodes and increase the computational power of the chip. The excessive heating and the reduced surface area can cause chip and device failures.
While this may not seem like a big deal it is addressing the concept of Moore’s law which is a manufacturing law that states that technological innovation should increase about every two years in order to maintain demand. However, over the last decade semiconductors have decreased in size and reached a point where they can no longer handle the amount of heat they are producing while remaining a viable product.

While this exciting technology remains unproven, it’s currently in beta testing and moving into trial production phases with several unnamed companies as they are unable to disclose their names. If successful, and they assume a 1-2 year timeframe to move into production, they will be releasing this technology at just about the same time that semiconductor manufacturers have reached the limit for their technological output.

In short, there is a lot of huffing and puffing over a little bit of nothing. The federal government continues to misunderstand the biggest economic sector of the country. The technological needs of our society are being developed as necessity deems.
And if you’re a developer, this means your skills are needed now more than ever. No matter what side you take on the “shortage crisis”, it’s going to be developers that are applying the power of semiconductors to the devices they run on.

Meteor.js

JoeTags — Mon, 09 Aug 2021 13:47:32 +0000

The development framework that is ‘outta this world’!

Meteor.js is a useful development framework for Javascript developers. It’s open-source and platform agnostic, so you can write apps for both Android and ioS. The main use case for choosing this framework is that it’s a one-stop shop for quick and seamless app deployment combining both front-end and back-end functionality.
Front-End and Back-End Development

If you’re a fan of Javascript’s useful class- based data structures, Meteor is going to be a dream as its designed to work with many modern front-end frameworks(i.e. React, Angular, Vue, and Blaze). The benefit for the developer is that you can spend more time on building apps with great UI and UX and less time trying to integrate your components. The framework architecture is built upon Node.js, so most of you reading are familiar with how Meteor is making your API calls behind the scenes.

So, What?

Right now, you’re probably thinking why should I spend the time to learn another new framework when I can perform these tasks myself?.
The reason is that Meteor is going to send pre-rendered data to the client instead of an entire page of HTML which allows for quicker run-time. If you’re website is heavily focused on rendering images, this is going to boost the speed at which the images render and also improve the clarity as the processing is focused to only what is needed at that moment. This link, 'data on the wire', provides an in-depth definition so I don’t have to bore you. It also helps illustrate one drawback to using the framework that I will touch upon later.

First, let’s discuss the server-side benefits of Meteor and how it can streamline your web development needs.
Meteor uses a distributed data protocol wherein it can make queries and update server-side databases(i.e. MongoDb) and synchronize those updates. In developer speak, it provides excellent isolation and modularity. Isolation, in that, a company’s database can be stored and managed with a third party and modularity, in that, Meteor can access that database and provide real-time updates back to that company.
If you check out Meteor’s website, you can see that some pretty reputable businesses(i.e. Qualcomm, Ikea, Honeywell) choose to utilize these full-stack capabilities.

Now, you still might be thinking that Meteor isn’t a good fit for you. Maybe you develop your own apps and aren’t interested in how Meteor can work in a big company environment. Well, Meteor has something for you to.

It’s called Hot Code Push and its as cool as it fun to say. This is a feature that allows, you, the developer, to make updates to your apps without going through Apple’s app store review process. It circumvents the walled garden’s of Big Tech and provides your apps’ users with seamless updates and cool features when and how you want to deliver them! Not only that, in happens in real time while people are using your app.

As for drawbacks, there a few, first, you need to be an intermediate developer at least to utilize the framework even though it abstracts out much of the API complexities. This is because there is a lot going on behind the scenes. If you aren’t knowledgeable of these core fundamentals, you might not understand how to tie certain libraries together.

A second issue is that there seems to be some bug with Windows users’ ability to install the library. I attempted to install Meteor into VsCode to demo a little code and was unsuccessful. After doing some research, I found that it’s an issue that several users have had recently but there wasn’t a concrete solution posted in the Meteor forum or on Stack Overflow. If you’re on a Mac, I recommend going to their website and heading to the tutorials page to build your own app.
Another drawback is that it delivers the app with little to no HTML and that could cause some complications when it comes to webscrapers, like Google, collecting data about your app. Without HTML, google can’t get inside to provide information utilized in search engine optimization.

In short, Meteor is pretty unique and has great use cases for both enterprise grade code production or for the someone who just likes to code for fun. Give it a try!

Reference
Abstract vector created by upklyak - www.freepik.com