Forem: Ariel Davis

Venturing into Freelancing: My Story

Ariel Davis — Sat, 26 Aug 2023 22:19:34 +0000

Hello,

I'm Ariel Davis, and right now, I'm working as a Webflow freelancer. Before this, I spent about three years as a software engineer. I made the switch to freelancing in March of this year. In the last six months, I've gone from feeling uncertain about my programming career to not knowing when my next client will come along. I'm still new to this, so I appreciate your patience as I share how I got here. And who knows, maybe my journey will inspire some of you. Trust me, it's quite the adventure.

Day 0 - Taking a Big Step

Since I had experience as a software engineer, this change wasn't too crazy. But looking back, I could have handled it better. After I left my last job, finding a new one was tougher than I thought, even with all my experience. I applied for jobs like crazy, sometimes hundreds in a week, but nothing worked out. And the few interviews I did get didn't go well. It was tough, but I started to see it as a sign. A sign that what I was doing:
A. Wasn't working
and B. Wasn't making me happy.

So, I decided to switch things up. I still loved programming, but if the usual job route wasn't working, I was going to take matters into my own hands and start freelancing!

Learning First, Doing Second

First, I want to give a shout-out to Vako Shvili. His Udemy course "Complete Web Design: from Figma to Webflow to Freelancing" is amazing. He takes you through everything step by step, using projects to teach you the basics of Webflow and Figma really quickly. If you're even a bit interested in this field, I totally recommend his course – that's where I got my start.

During this course, I realized that even though I'd been a developer for a while, I knew nothing about design. I couldn't make a website look... well, good. This realization was a big moment for me. I learned about Figma, why certain fonts look better, how colors work together – it was like a whole new world. And when I started using Webflow, that's when things got even more exciting.

Webflow Magic

I'd heard of other website builders like WordPress and Shopify, but Webflow was new to me. Even before I learned all the details, I had a feeling it would become my favorite way to make websites. If you're thinking about learning Webflow, check out their free Webflow 101 course. It's designed for beginners, so you don't need years of experience to get started.

Looking Ahead

Having my past experience helped me learn Webflow faster, which helped me find my first clients more quickly. I'm testing the waters on Upwork, and I'm aiming to become a certified Webflow Expert soon. That should open up more opportunities with clients. If you've read this far, thank you! Feel free to explore my portfolio website, and if you're looking for a Webflow developer, send me a message.

Stay tuned for more to come…"

Expecting the Unexpected: Javascript Throw & Catch

Ariel Davis — Wed, 06 May 2020 20:04:21 +0000

Error Handling

Error's are and will always be a big part of a developers life. They are what allow us to see what mistakes we made in out code, and learn more and more about what's going on behind the scenes. Sometimes however, we expect to get back and error from the code we've written. We need a way to handle this situation. This is where Error Handling comes into play.

Flatiron School

I am Ariel Davis, a current student at Flatiron School. I've come across error handling without going into too much detail a lot throughout my time at this school. After sitting down to really get an understanding of when to use error handling has been of great use to me and I can only hope it will be of great use to you as well. In this blog, I will go over when, why, and how, to use error handling in Javascript.

When?

When is it a good time to use error handling? There will be many times while programming when you come across an error. You shouldn't have the mindset of, "Oh there's an error, let me use error handling". Rather you should think like, "I know there are set conditions that would make this throw an error, so let me handle it." You should only use error handling when an error is expected to happen based off of certain conditions.

Why?

Why we should use error handling ties close to when we should use them. When your program throws an error that you are expecting, it will more than likely crash and burn. We don't want this to happen while our application is being used so we throw and catch an error.

How?

The bread and butter of this blog. How exactly do we work with error handling? In Javascript we use what's called the try...catch syntax:

try {

//Some code that may throw an error

} catch (error) {

//Some code that happens if/when an error occurs

}

The code in try{..} is what is initially ran in your program.
Depending on if this piece of code throws an error or not, the next block of code catch(error) {...} is ran.
For example:

try {

console.log("Super cool console.log")

} catch (error) {

console.log("This console log won't run")

}

However:

try {

console.log(undefinedVar)

} catch (error) {

console.log("This console log will now run")

}

Because the variable undefinedVar isn't defined, an error is thrown. Now normally this would end the program, but with the error handling in place, the program will continue and run the console.log:
console.log("This console log will now run").

The Basics

That is the basic concept of error handling, some nice resources that can be used in order to get a different explanation of the try...catch syntax can be found at these links:
Try and Catch Article
MDN Docs
W3Schools

JavaScript: Playing Fetch With Data

Ariel Davis — Tue, 14 Apr 2020 17:23:59 +0000

Hello fellow full stack developers. In this blog post I will be discussing an important topic. Yes this topic is about using JavaScript to be able to communicate with that super cool data in your backend. Let's get started.

For this blog, we will be using Ruby (Ruby on Rails) as our backend and JavaScript as our frontend.

Why?

Why would I want to get data from my backend and manipulate it on my frontend..ew? Well not ew. In this day in age, we want to have dynamic applications that give users a grand experience. We don't want stale, static applications that don't change. This is why we use and manipulate data (our backend) so that we can make and persist changes on the fly. Today, we will just be looking at how to "GET" that data.

Setup

So I'm going to assume you already have a backend database that you would like to work with (using Rails as your API), and your here to find out how to connect it to your frontend and work with that data. Cool? Cool.

Once you have your super cool Rails database that you are ready to work with, do ahead and start up your server. Check out that data that you are gonna work with.

(This will be at the INDEX route sticking to restful routes, that should already be set up)

Usually this data will be at:
http://localhost:3000/#{some_cool_thing}

Yay some nice data. But how do we get this data in out frontend. Well lets move over to a JS file we've named index.js
We are going to use this file to get that super crazy amazing cool data from our database, this is where FETCH comes into play!

Fetch

Inside of your index.js file--

(as a side note, make sure that this file is linked to you HTML file with script tags)

We are going to write the word that will allow you to unlock your data. That word..fetch.

Cool. We're done.

Just kidding. This method however, is the key to getting out data from our back end. The fetch method takes two arguments. The first is a URL (Yes! For those who guessed, our database URL) and the second is an object (we wont worry about that right now). What we are going to do is put the URL of our database as the first argument in the fetch method(as a string).

If we were to console.log() this we would get the following in return:

What is this weird thing..a "Promise". This isn't the data that we want back. Well essentially a Promise is JavaScripts way of telling us that we have the data that you want and we are definitely going to give it to you, just not yet.

.then and a Response

So what can we do with this Promise to get the data that we need? Well once we get this response .then we want to get our response. If you got the hint, we are goin got use .then on our fetch. This will give us back a response.

If we console log this we get back:

With this response we need to be able to convert it into some usable data. JSON data to be specific. We take the response that we got and parse it into a JSON format with .json().

Our Data!

Great we are almost there! With this new Promise (console log what we just did, we get back a promise again) we can .then get back the data we need. Got the hint again? We use .then again, but this time we get back:

In the console:

We get back and Array of Data!

Conclusion
We can use this data now in different methods and functions in order to manipulate it to our liking. This is just the beginning to getting our data and using it. We can make POST, PATCH, and DELETE request using fetch that further expand our super coding abilities. For now though, this is how you FETCH data in JavaScript.

Simple Weighted Random Number

Ariel Davis — Tue, 24 Mar 2020 19:51:56 +0000

Flatiron Student

I am currently on my 6th week at Flatiron School and I've it has been a roller coaster for sure. It is project week for us and a problem that I was facing in my project was working with probability. Now probability when working with Ruby (or from my research ANY language) can be either simple..or complicated enough to make you want to throw your laptop..needless to say..I almost threw my laptop.

Simple Stupid

I want to share with you my simple way to work with weighted random numbers (probability). Now as a disclaimer this is NOT THE MOST EFFICIENT METHOD TO WORKING WITH WEIGHTED RANDOM NUMBERS. This post is for a simple solution that has limited application.

More Than One Means

The basis of this solution to working with weighted probability is the following:
The more the are, the more likely it will get picked
If I had the following array:
arr = ["test1", "test2", "test1", "test1"]
and were to run the following method:
arr.sample
There would be a greater chance that test1 will be chosen from the .sample method.

Not DRY at all

This can lead to a lot of repetition in your code so to be honest I'd stay away from using something like this unless you were:

Working with a very small amount of data

That's it. Don't use this unless you're working with a small amount of data.

I will definitely continue to do more research in working with this and come back with a more advance way of working with weighted probability and make it as understanding as I can. Until then..