Creating an application using Vite

Up until recently, you could create a React application using Create-React-App. It was a lightweight way to create React applications quickly and was supported by the React documentation. Create-React-App has been discontinued - it will still work I suppose, but it is no longer the recommended way to create React applications.

I first came across Vite while going through freeCodeCamp's new curriculum. About a week later, while furthering my React studies on Scrimba, they also suggested using Vite as a worthwhile replacement. After building a few projects, I definitely agree.

Vite is a build tool for creating React applications. Of course, I could try to create my own React applications using no build tool, but that can take a long time and there are many files to configure. If someone else has done this work already, I'm going to take advantage of that! 

In order to use Vite, you need to install Node.js if you haven't already, and it needs to be a version higher than 18.0.0. Originally I had a higher version of Node installed (I think it was 22.0.0. or 23.0.0, I can't remember), and that caused some trouble with using Vite. Currently at the time I'm writing this, I'm using Node version 20.0.0 with zero issues.

Once Node is installed, do the following steps:

1. Navigate in your terminal to the folder you want your project to be stored in. For me, I usually change my directory to Desktop and store my project there.
2. Run npm create vite@latest 
3. This will start the tool's prompts. It will ask you just a few questions:
1. What is the project's name? 
2. What library/framework are we using? 
3. What language do you want to focus on? (For example, when I choose React for question #2, it will then ask if I want to focus on JavaScript, Typescript, or a few other options).
4. Once these questions have been answered, Vite will build out the project. At the end, it will give you three commands to run in a row:
1. cd <project-name>
2. npm install
3. npm run dev
5. That last command will be one you probably use a lot, as it is the command that starts up the live server so you can see your work rendered in the browser. I personally find myself starting and stopping the server as needed, usually when I need to use my terminal for something.

And that's it! In the folder you selected, your new Vite project will be created. At this point, you can go into the project itself and clear out all the default stuff (styles, text, images, favicons) and begin creating your JSX files, stylesheets, and link them together.

Documentation link: https://vite.dev/guide/

Common String methods in Java

Almost all programming languages use Strings I'm sure. In Java, they are used a lot, and the language even made Strings it's own class. So, unlike other data types like `int` or `boolean`, Java's String data type is actually an object which is why we capitalize it when initiating a string.

Since String is an object, it also comes with it's own String methods. A full list of String methods can be found at this W3Schools link: https://www.w3schools.com/java/java_ref_string.asp

Below are some common ones:

• length(): returns the length of a String as an int
• concat(arg): returns a combination of String1 and the arg of the method - which could be another String or a mixture of blank spaces and a String.
• String1.concat(" " + String2); as an example of multiple values in the argument
• indexOf(arg): returns the index of the argument given
• charAt(arg): returns a character at index arg
• equals(arg): you cannot use the == operator to compare two strings in Java, so you need to use this method instead. This is case sensitive, but you can also use equalsIgnoreCase() as an alternative if you don't care about the case (or don't want to for the sake of your program's objective).
• substring(arg, [arg2]): this returns a String that falls in line with the argument(s) you give the method signature. If you give just one argument, it will return a String that starts at that index all the way to the end of the String. If you declare two arguments, it will return a String that starts at the index of the first argument and will go up to but not including argument two.
• toUpperCase()/toLowerCase(): these return a string in all caps or all lowercase. This is good for situations where you want to make sure case is ignored and you just want to compare the characters in the String.

Writing my first SQL program

This was part of a Codecademy exercise in their intro to SQL course. Since I recently worked on my first story at work that required new SQL code to be written, I figured now is as good a time as any to start learning SQL.

 

Each step involves SQL "clauses" which are like keywords. They can also be referred to as "commands". The primary clauses here are:

• CREATE TABLE
• INSERT INTO
• UPDATE
• ALTER
• DELETE FROM
• SELECT

There are other helper commands being used like:

• SET
• WHERE
• FROM
• VALUES

These helper commands pair with the primary ones above to create SQL statements. Every statement ends in a ;. From experience, if you omit a semi-colon, the language will not run. This is much stricter than JavaScript.