DEV Community: Kevin Steele

What I learned my first week on the Job.

Kevin Steele — Tue, 09 Apr 2019 11:01:40 +0000

Some things I Learned on my first week as a Dev

I recently started my first job as a web developer and I would like to share a few things I've learned. I'll format this as a list, so here we go!

You belong

It doesn't matter if it's your first job or your latest role. You were hired because your employers believed in you. So do yourself a favor and believe in yourself too.

Ask clarifying questions

If you don't understand something, your senior devs are not there to judge you, they are there to do their job. Part of which is to give and receive critique and help where they can. A gap in your knowledge base is not as embarrassing as not telling your lead when there is a problem.

Volunteer but don't overreach

I suffer from a chronic need to prove myself. When things get too heavy on someone else's plate, you can help but don't overextend yourself if you know you've been given other directives to achieve. Your work takes priority!

Google stuff first!

Yeah, this may feel like a bit of a no-brainer but some ask questions not about a codebase but about something that can be referenced easily. For example, if you don't know the name of an array method, you probably should look it up first.

Function over perfection

We often talk about ideal conditions, greenfield projects, professional coding practices. However, nobody can write the cleanest code to begin with. Just focus on writing small, effective functions and remember to name your variables reasonably. New and old devs alike, have to rewrite things. Writing imperfect code, to begin with, is not a cardinal sin.

You will fail but you're not your mistakes

I'm not trying to be disparaging but it happens. Things fall apart. Even senior devs make mistakes and there are always things you may miss or were not told because specifications were not available. It just happens. And I want to tell you that it's okay. We learn far more from our mistakes than our successes.

Don't lose yourself in work

Ride a bike, play a video game, go on dates. You're a human before you're a developer and I know it's an exacting job. But that's the thing, it's a job. I do side projects but I also spend time with friends, do person stuff.

Have fun!

I mean it. Enjoy the journey. Focusing on growth is fine but not at the cost of your personal relationships or health. We work to live not the reverse. And don't forget it!

In closing

Sorry that this wasn't a technical blog but I feel that we tend to understate the importance of soft skills and emotional health. As always I welcome any comments, critiques, and feedback. Thanks for reading.

What should I write about next?

Kevin Steele — Mon, 01 Apr 2019 01:15:53 +0000

Hi all, I wanted to touch base with you all and ask everyone what topic(s) I can cover or you would like covered. Let me know in the comments.

I got my first job and it's a contract, what now?

Kevin Steele — Tue, 26 Mar 2019 18:04:34 +0000

Hi all! I didn't make my usual, weekly blog post because I've been busy onboarding and such. I want to ask the Dev.to community something. I recently started as a contractor with an at-will agreement and many of the people working there as salaried employees used to be contractors. What are some next steps I can take to become salaried there or find full-time work as a developer once the contract ends? I'm at a bit of a loss.

Where do I start? Part 4: JavaScript OOP, Context and Class

Kevin Steele — Mon, 18 Mar 2019 10:19:16 +0000

Didn't you just write something about this last week?

No, I made a listing of resources for JavaScript without the trickiness of its implementation of Object-Oriented Programming included. Some of the resources cover it but not extensively, except for in the case of the Free Code Camp one I believe.

What are we gonna learn about this time?

Object-Oriented Programming

Yeah, I know I keep saying it but let's cover some vocab first. Last time, I mentioned Objects as being a data type but I didn't really address the difference between an object and the other data types, or primitives. In JavaScript, everything is an object and that leads to some interesting problems. Namely binding.

Primitives

A primitive is an immutable or unchangeable data type that has no methods that mutate the primitive itself. Current year JavaScript has 6 kinds of primitives:

strings
- "hello"
numbers
- 123.456, 1, -12
booleans
- true, false
null
- null pointer reference, a reference that points to nothing
undefined
- default primitive value assigned to a variable when it's not defined
symbols
- I could write a blog about these, I probably will. For now, they are used as dynamically produced distinct anonymous values. It's okay if you don't get it.

There are sub-categories like integers and such but that's not that important at the moment.

If primitives are immutable, how come I can do this?

     let greeting = "hello";
     greeting += " and goodbye"; // greeting equals "hello and goodbye" now

In this snippet, you're not actually changing the string primitive "hello" into "hello and goodbye" you're changing the assigned value the variable greeting has.

What makes Objects so special?

Objects are typically used to group together related information. Be they values, functions, or otherwise. It's a data structure. Often objects are used to create abstractions of real-world things and concepts like shoes or dates. You may also hear words like dictionaries or hashes thrown around. These are all objects. The important through-line is that they all have key-value pairs.

Key-Value pairs

Yes, key-value pairs. Objects have attributes that have different values and the keys are used to access the value whatever it may be in relation to the object. Ergo the name key-value pair. For example:

     // initializing a shoe object
     const shoe = {};
     // it's looking lonely let's give it a type or something
     shoe.type = "sneakers";
     // what's it made of ?
     shoe.materials = ["nubuck", "rubber", "EVA"];     
     // and you can nest objects inside of objects indefinitely, you might not want to nest them too deeply
     shoe.company = {
          name: "Anon shoe Corp",
          address: "123 None of your business Ave."
     }
     // and who makes them
     shoe['getCompany'] = function() {
          return this.company.name;
     }

     console.log(shoe.type); // prints out "sneakers"
     console.log(shoe['materials']); //prints out ["nubuck", "rubber", "EVA"];

I'm swapping on purpose between the object.key and the object["key"] notations. They mean the same thing but have different uses. If you are iterating through an object with a for-in loop you had better use the square bracket object['key'] notation inside the loop, but you won't need the quotes because for-in supplies you with the key as a string. Bracket notation uses the literal key as a string to access the value. On the other hand, if you know the name of the key and it isn't something like, "I have spaces", you can assign or access its value with dot notation.

You said something about context, right?

Yes, but first I'll show you some code and explain as we go.

     function greetings (greeting) {
          // the this keyword refers to the object that the function resides inside or its context
          return greeting +" "+ this.name;
     }
     console.log(greetings("Hello")); // "Hello undefined"

     const James = {
          name: "James Walker"
     }

     console.log(greetings.call(James, "Hello")); // "Hello James Walker"

The this keyword refers to the context the function is being invoked in. By context, I mean where the function resides or what it's bound to when called/executed. On the first invocation of greetings we get "Hello undefined" because the context of this first invocation is global. There is no value assigned to this name property globally so by default it's undefined. After we make another object that can provide context, we bind the function to that object to give it a defined execution context. Call is one of three special methods that explicitly bind the greetings function to the James object which provides it context for the name property. So when it's invoked in that context, it returns "Hello James Walker". The first argument is always the invocation context followed by the remaining arguments that need to be passed. In other words this in that execution context is the James object so this.name on the second invocation is basically James.name.

That's nice and all, but what if I want to write a piece of code that makes the objects instead of coding each one by hand?

We used to use classes for everything and there are cases where we still do but I'll show you this and then tell you why it's to be used sparingly. There's a famous example called the Gorilla Banana Problem.

     // old-school ES5
     // creates an object with a constructor function
     function Vehicle(make, model, year) {
          this.make = make;
          this.model = model;
          this.year = year;
     }

     // The prototype refers to an object inside of vehicle, all objects have a prototype object inside and it's used to pass down attributes or make new ones
     // we then create another attribute with the key of getInfo and its value is a function that prints out information about the Object.
     Vehicle.prototype.getInfo = function() {
          console.log("This is a ", this.year, " ", this.make, " ", this.model);
     }

     // Bicycle subclass, Vehicle being the superclass or parent
     function Bicycle(make, model, year, speed) {
          // using call redefines the execution context to the Bicycle object, not the original Vehicle constructor
          Vehicle.call(this, make, model, year);
          this.speed = speed;
     }

     // es6 style
     // much closer to traditional OOP languages in the "new" es6 syntax
     class Vehicle {
          constructor(make, model, year) {
               this.make = make;
               this.model = model;
               this.year = year;
          }

          getInfo() {
               console.log("This is a ", this.year, " ", this.make, " ", this.model);
          }
     }

     // let's make a subclass
     class Bicycle extends Vehicle {
          constructor(make, model, year, speed) { 
               // super is used to pass arguments to the class Bicycle is derived from
               super(make, model, year);
               this.speed = speed;
          }
     }

     const bike = new Bicycle("BMX", "Stormbringer", 1999, 5);
     bike.getInfo(); // logs "This is a 1999 BMX Stormbringer"

Prototypes are objects that exist inside of all other objects as a sort of kernel. This kernel is where all your properties and functions reside. The prototype may also contain another prototype that it inherits functions and properties from ad infinitum. The access derived or sub-classes have is referred to as inheritance which is provided by the prototype chain. Prototype chain is just a reference to how all classes inherit from all the prototypes of their previous ancestors forming a chain or prototypal inheritance.

The second, ES6 version is written in a fashion anyone with some OOP language experience can recognize. This was part of the reason this syntax was implemented. It makes it easier for JavaScript folks to get to grips with OOP coding and it gives folks who don't know it so well a foothold if they already know an OOP language or two. Plus explaining what prototypes are and the this keyword means can get confusing. ES6 has made great progress in simplifying JavaScript syntax as a whole.

Long story short, prototypal inheritance was a necessary evil and even with the new conventions, it's still there beneath the surface. That being said, OOP is still prone to certain problems and is by no means a panacea. I will address these issues next time as well as some solutions and more resources.

Parting words

Next time, I'll bring you some more resources and as always I am not infallible, please comment, critique, and reach out. I am just starting my career and would love to get better and provide more value to my fellow comrades-in-keyboards.

Resource links

Videos
- Traversy Media
  - JavaScript OOP Crash Course - 40 mins
- Programming with Mosh
  - Object-Oriented Programming in JavaScript - 1hr
- Academind
  - Reference vs. Primitive Values/ types - 21 mins
Sites/ Reading Material
- MDN
- W3Schools
  - JavaScript Objects
  - This keyword
  - Object Prototypes
    - Tyler Mcginnis
  - This keyword, call, apply, and bind

Where do I start? Part 3: JavaScript

Kevin Steele — Mon, 11 Mar 2019 03:28:16 +0000

This time

Hi all, I'm back with another installment of these lists of lists. This time around I'm talking about JavaScript. So as always, I'm just some guy and by no means an expert please correct me in the comments if I'm talking out of the side of my you-know-what.

JavaScript

JavaScript is an amazing language. You can manipulate the DOM, build games, and make cool apps. There are many things you can do in this language but I'll highlight some of the things beginners need to learn and most of this will apply to other languages as well.

I said in a previous post to learn JavaScript after all the other things like HTML and CSS. But, if you really want to learn JavaScript, do so in isolation and that's how I would tell you to practice, at first. But if you're already familiar with HTML and CSS, go for it! I believe in you!

Things to learn

There's a lot to learn in any language and it can be confusing for your first so here are some personal favorite resources on learning JavaScript.

Topics to Study:

variables, how to define them
- let & const (don't use var, I mean it!!)
- variable scope (is the variable accessible)
data types
- number, string, boolean, symbol
- type conversion and testing, typeof
reference data types
- objects, arrays, etc.
operators
- addition, subtraction, division, multiplication, and more!! (+, -, /, *)
functions
- a reusable piece of code that is sometimes called a procedure if it doesn't return anything, but everyone just says function, unless they're being fancy or pedantic
- control flow
  - loops
    - for, while, for-in, for-of
  - conditional statements
    - if, else if, else, [try, catch, finally] -> debugging
keyword this
- call, apply, and bind -> when/how to use them and where
arrow functions
DOM Manipulation
- create, remove, modifying an element
- adding CSS class to element to modify it

Resources

Courses
Videos

Free Code Camp
TraversyMedia
- JS Fundamentals for beginners - 1hr
- JS DOM Crash Course pt. 1 - 39mins
Sites
Recommended Reading

If a book has a legally free version, I will link it. Otherwise, I'll link to its Google books page.

Next time I'll share some links on learning OOP or object-oriented programming in JS and how their classes work. There is a wealth of resources online and I can't hope to cover them all but I think these are pretty good and as always I'm open to any comments, critiques, or call outs.

Where do I start? Part2: CSS Pre-Processors

Kevin Steele — Mon, 04 Mar 2019 01:54:23 +0000

Last time...

Last time I posted in part-0 some of the things you may want to start doing before working on anything in part-1. We'll start off with the assumption that you have a decent grasp of both HTML & CSS, you can use a text editor, and know enough git and command line commands to do most of what you need without using a UI.

I know HTML, CSS, and all that, now what?

So if you're feeling this way, you've probably done some if not all of the following:

Made a static website
Learned Mobile first or Responsive styling
Worked on Free Code Camp Responsive Web Design Projects or projects like them.

If not, you can start with these HTML or CSS courses at Free Code Camp or use whatever resource/s that best suit your learning style and needs/goals. If you want to code as a hobby, that's fine too. I'll save the JavaScript post for later because the length of this one has become a bit much.

CSS Pre-Processors and JavaScript

Modern CSS makes it much easier to style pages than compared with the bye-gone days of MySpace pages and Friendster. But even if you adopt amazing CSS architectures like SMACCSS or stick to your basic BEM, large or complex projects can make it harder to generate lean, effective CSS. Enter CSS Pre-Processors, they generate CSS thus the name and they have really neat functionality. Such as:

less stuffy syntax
nested selectors to simplify and cut down on classes and modifier use
has data types you can use for better interaction
functions w/ arguments
control flow
and more!!

I'll give an example using SCSS

You want to perfectly center a tag in relation to its height but it's also nested in another tag but the parent's positioning is absolute or relative to its own parent. What would we do?

  /* In CSS */
  div.parent {
    position: absolute;
    top: 0;
    left: 0;
    width: 100vw;
    height: 100vh;
  }

  /* Had to write a specific selector */
  div.parent > div.child {
    --child-height--: 35vh;
      position: inherit;
      margin: 0 auto;
      /* Seems like a lot to write just for this */
      margin-top: calc(50vh - calc(var(--child-height--)/2));
      width: 35vw;
      height: var(--child-height--);
  }

  /* In SASS */
  $child-height: 20vh; // reuseable in multiple places

  div.parent {
    position: absolute;
    top: 0;
    left: 0;
    width: 100vw;
    height: 100vh;

    div.child {
      position: inherit;
      margin: 0 auto;
      margin-top: 50vh - $child-height/2; /* Cleaner */
      width: 35vw;
      height: $child-height;
    }
  }

Now imagine adding more tags and styling where that came from. You can pretty much predict the mess that your CSS files could become. Before the advent of CSS Pre-Processors you had to write more selectors, use more classes, and it lacked the extensive functionality afforded by CSS Pre-Processors like SASS.

Resources

Documentation
- SASS
- LESS
- STYLUS lang
- post CSS
Videos
- Sass Crash Course by DesignCourse
- LESS CSS Pre-Processor Tutorial by Traversy Media

Next time

Next time we'll finally look at JavaScript. A brief overview of the basic syntax and control-flow, recommended reading, and other resources. As always, I'm new so I acknowledge that I may make mistakes and am open to critique, discourse, or suggestions. Thank you!!

Where do I start? Part 0: Bash Terminal, Git and Github/ version control

Kevin Steele — Mon, 25 Feb 2019 02:21:57 +0000

Where do I start? Part 0: The Terminal and Version Control

So where's Part 2?

I did mention in Part 1 that I would follow up with a prequel of sorts focused on things you should probably have at least a passing grasp of. In this installment, I will be covering resources for the terminal and version control. So without further ado, here we go.

So what's a terminal?

The terminal is an application that directly interacts with the computer via typed commands as opposed to point-and-click GUI operations. The name terminal originates from the olden days of computing. Terminals were once a physical machine used to interface with computers the size of large rooms which you did by typing in commands literally and the idea kind of took root since then. By entering commands manually and strategically you can reduce the amount of time it takes to do fairly involved operations in the GUI with ease from the terminal. You may also hear terms like the command line, shell, bash, or console. However, in most cases, it's probably the terminal that's being discussed. If you want to get pedantic, look at this.

NOTE: This is my personal opinion but I strongly prefer git if I'm using a windows machine (I use Chromebooks, Windows machines, and a mac so...). While PowerShell is decent, the command prompt is pretty bad by comparison which is why unless you use .Net or something, it's generally not encouraged. But that does not mean you cannot be a unicorn and go ahead and buck the trend but you'll have to learn something Linux-y eventually.

The following are my recommendations for what terminal interface to use with which operating system and some links to educational resources.

Download Links
- Windows (if you are using windows 10 look at the Linux subsystems links)
- Mac (the terminal it comes with is fine but if you're fancy..)
  - Oh My ZSH
- Linux (it comes with Linux, the GUI is the extra part!!)
Sites/References
Videos

Version Control and Git

Let's say you want to build a feature for a piece of software but you're working with a bunch of other people. How do you work on the same project together without messing each other's code up? Enter version control and git.

Version control is a system that keeps a record of a file or several files over their lifetime. You can access older versions later on if you need to or completely overwrite things if you so wish.

Git and GitHub

You'll hear Git and GitHub used interchangeably but the difference isn't that complicated. Git is a revision or version control system and GitHub is a service that hosts or stores projects that use Git. There are other hosting services like GitLab and GitBucket, but GitHub is the accepted standard in open source. It's ostensibly free (charges for private, team only accessible repos).

Sites/References
Videos

Next time I'll return to form with some short descriptions and resources for learning JavaScript and CSS preprocessors. As always any comments, concerns, and critiques are welcome.

Where do I start? Part1: IDES, HTML, CSS, & CSS Frameworks/Libraries

Kevin Steele — Mon, 18 Feb 2019 04:22:53 +0000

Who is this for?

I would like to say everyone, but it's mostly for beginners who want to develop for a living. If you know something on this list or want to contribute, there's always the comments. I also love finding new resources.

Where to start?

Just pick a thing. But if you want to do web development you're gonna have to tangle with HTML, CSS, and JavaScript eventually. If hearing things like front-end, back-end, or full-stack gives you anxiety, I would recommend starting with front-end development. Front-End is a great place to start and you can begin with just making static websites. So no tricky JavaScript or anything, at first. Just worry about building the structure, customizing the layout, and how it looks.

IDEs, REPLs & Text Editors

To code you'll need either some sort of Interactive Development Environment or IDE, or a text editor like Notepad. But I would suggest you use a code editor.

REPL stands for Read, Eval, Print, Loop and there are neat online ones customized to be used for whatever environment you're using. If you need to test out a function or code snippet, use them.

Resources
- Desktop IDEs
  - VSCode
  - Sublime
  - Atom
- Online IDEs/Editors
- Online REPLs
  - Repl.it (only one you need, trust me)
Videos
- Traversy Media
  - VS Code Guide and Setup
  - Atom Editor packages and set up

HTML & CSS

So we start off with HTML and CSS. If you see things like HTML5, don't panic that's just the most recent iteration of HTML or hyper text markup language. CSS stands for cascading style sheets. You'll hear things about CSS frameworks and stuff but learn enough plain css to make basic cosmetic and layout changes to pages first. I would strongly recommend you learn the following before using CSS frameworks or libraries for anything besides cosmetic changes (unforseen side-effects may occur):

I'll be addressing CSS frameworks after this section. But below is a listing of links I find or found helpful on my journey.

Sites/Reference:
- Mozilla Developers Network (dry but super thorough)
  - HTML Docs
  - CSS Docs
- W3 Schools (beginner friendly)
  - Learn HTML
  - Learn CSS
- Rithm School (Free Online Curriculum w/ some videos)
  - HTML & CSS Basics
- Learn to Code HTML & CSS (online book)
  - Basics
  - Advanced
- CSS Tricks (advanced CSS tips and tricks, also good breakdowns)
- CSS Interactive Cheat Sheet
- HTML Interactive Cheat Sheet
Videos (YouTube, Scrimba, etc):
- Traversy Media (king of crash courses)
- Free Code Camp Videos info
- Scrimba Intro to HTML
Interactive Tutorials & Drills: Use these to sharpen your Flexbox and CSS-grid skills

CSS Libraries/Frameworks and more, or Bootstrap and friends:

So you've safely emerged from the tall grasslands of HTML and CSS on your web developer journey. What lies before you next is the expansive plains of CSS frameworks and libraries.

There's a lot of confusion about what constitutes a CSS framework vs. a library and I'm not gonna get into that here. Instead I'll just show you some possibilites. This list will focus on what's popular and/or good. These are not necessarily the same thing. Popular libraries/frameworks almost always have a large, supportive community with robust documentaion, while the ones considered good may have the same support but solve a particular problem well or better than others.

Sites/Reference:
Videos:
- Traversy Media
  - Skeleton Landing Page
  - MaterializeCSS Crash Course pt. 1
    - pt. 2
- Design Course
  - Bootstrap 4 Crash Course

Online Curriculum:

These links are complete repos, lists, and curriculum you can follow if you feel lost. But remember devs are paid for thinking so if you find something that doesn't work for you, pivot or come back to it later. Be kind to yourself!

[Edit]: Next I'll add a part 0 where I'll talk about some resources for learning the bash terminal/command line and version control with git/github.

Database models and ERDs for Newbs Part: 5

Kevin Steele — Wed, 06 Feb 2019 07:31:09 +0000

The CRUD operations

Recap

Last time we delved a bit into SQL using PostgreSQL's command line tool, psql. The database was created, tables made, and rows inserted.

What now?

This is a bit unorthodox but I'm trying to ramp up to 2 posts a week on average so I'm concluding this series here. But, before I close on this, I'll be going over a few things in SQL. Specifically how we insert rows into our join tables, make instances/rows of the models the join table refers to, update a row, and finally delete a row and delete the whole dang database. So I'll write up some scenarios with them to justify doing the code.

Let's access our database.

Since we already have made the database in the last entry this is how we access it using psql.

Creating rows!

Scenario: Professors Elizabeth King and James Marshal just got hired to teach a couple of classes. They need to be entered into the database before their courses can be determined.

Professors Table:

id	first_name	last_name
1	James	Marshal
2	Elizabeth	King

Scenario: The newly hired Professors Marshal and King teach an English and Math course respectively.

Courses:

id	title	description	professor_id
1	Freshman Math	A mathematical survey of the...	2
2	Middle English	Middle English, Chaucer and beyond	1

Scenario: Student ID number 1, Adam Bean registers for both of the new courses taught by the new professors. Student ID number 2, Clara Doe registers for only the Math class since she transferred with the appropriate pre-reqs. And Student ID number 3, Everett Franklin just wants to read Chaucer so he registers for Marshal's course.

Here, we have inserted professors, courses, and the course_registrations. Pay close attention to the course_registrations table. It only has its own id number and two foreign keys, one refers to a course row and the other to a student.

Course_Registrations:

id	course_id	student_id
1	2	1
2	2	3
3	1	1
4	1	2

Reading from a single student with ID of 2.

Scenario: Clara needs to be looked up to confirm some information for the admins.

Updating a student's last name.

Scenario: Clara gets married and wants to adjust her student info to reflect her legal status. This is how you would change her name.

Deleting a row.

Scenario: Everett wants to transfer to a school that better fits his needs and so his record needs to be removed. We delete a row like this:

Droping the database.

Scenario: The college is about to close down but their database contains sensitive information so the entire database needs to be deleted. The following code is how you would remove or drop the database.

And there you have it CRUD! I had a lot of fun making the diagrams on such over the last 5 posts or so and would be open to any feedback. Thanks for reading!

Database models and ERDs for Newbs Part: 4

Kevin Steele — Mon, 04 Feb 2019 03:17:16 +0000

Recap

So last time we fixed up the students, professors, and courses relationship. This was done by the amazing application of join tables. Join tables basically, hold references for 2 or more database models that would otherwise have a many-to-many relationship. Which is problematic because it creates a situation where data is duplicated in a bunch of places, leading to low cardinality. Cardinality basically refers to how unique data is in a particular column. While join tables aren't perfect, it's better than keeping entire copies of rows (individual instances of the model) nested in other rows.

Corrections

I made an assumption about the data model for the student based on the desire to show a greater variety of crow's foot notation. But the has one or more course_registrations demarkation of the student is confusing when you think about it. It would lower cardinality so I'm just going to add a boolean data type column called has_registered to alleviate this.

It took this.

And made it look like this

Code, yes?

Not quite yet, first some errata.

I am by no means a DBA(database admin) or anything so I'm not going to get too deep into joins in this one.
I'm using PostgreSQL. If you don't have it, here's a download link.
I use an ORM (Object Relational Mapper) in production but you should always know what's going on "under the hood" of whatever abstraction you're using, to a degree. This hopefully sheds some light on what the tools you are using to spin up databases are actually doing.
There are visualization tools and managers to help you with your databases like pgAdmin. Download it, play with it!
Forget the UUID thing. It's neat but I don't think introducing modules in PostgreSQL befits a beginner
I am also omitting what a full-blown version will look like. There's a lot of data to consider and will go into detail on something similar later.
And finally, at this point, I'm assuming you downloaded PostgreSQL and have it set up.

So here we go:

First, we go the terminal, git bash or power shell (you should be using one of these!) and enter the following:

So in the above code, I entered the DBMS (database management system) and then I created the database that holds my tables. I affectionately called it school_server.

Next up, the tables themselves.

So here I made the professors, students, courses, and course registrations tables. Pay close attention to courses and course_registrations tables. They both contain some foreign keys.

Sounds familiar?
It should, I mentioned previously that foreign keys are used as references that point to the appropriate row in the table that has a relationship with the row that contains that foreign key.

In the case of the courses and course_registration tables, we see 3 different foreign keys. Courses have only one, in the professor_id column. Course_Registrations has two because it is a join table that joins together courses and students. Which are also what its foreign keys point towards. So let's have a gander at what these newly-minted tables look like.

Professors

id	first_name	last_name

Courses

id	title	description	professor_id

Course_Registrations

id	course_id	student_id

Students

id	first_name	last_name	has_registered

This is getting to be a bit long (vertically). So I'm going to call it quits here but, before I close I'll do show you one more thing.

Create Students!

And now our table of students looks like this:

id	first_name	last_name	has_registered
1	Adam	Bean	true
2	Clara	Does	true
3	Everett	Franklin	true
----	----------	----------	---------

Next time, I'll cover the getting a specific student's data, updating, and deleting in SQL. See ya!

Database models and ERDs for Newbs Part: 3

Kevin Steele — Mon, 28 Jan 2019 04:16:19 +0000

Recap from Last Time

Last time, we looked at a mock school registry with 3 tables: students, professors, and the join table of course registrations. I also promised to do some coding and that's what I intend. So here we go!

Remember This?

So what's wrong with this?

course registrations only join students to professors (no courses to be seen)
we need to record the classes/courses themselves w/ their own id numbers, names, etc
you need to be able to generate a student roster for individual classes

Fixing the Problem

So here's what I came up with.

So we revised the models and their relationships in the following ways:

made it so that a single course belongs-to a professor
course registrations belongs-to both courses and students
a course registrations entity has a professor through its course it belongs-to

Next, we'll see what a row of the course registrations table looks like now as opposed to before

Before:

id	professor_id	student_id
123	37494	746384684

After:

id	course_id	student_id
123	7893726	746384684

Why all the id numbers?
High-cardinality is the ideal for SQL databases and this solution promotes high-cardinality more than the previous version. It's more reasonable to store references to the model than to clone the database models for a few reasons. Especially since when you have to update or delete a model. If you made clones instead of used references, you would have to repeat the same operations in multiple places and that would lead to mistakes so references are used instead.

Introducing Foreign Keys
The course_id and student_id are the references used in my example and they have a specific name, foreign keys. Foreign keys don't need to be named after anything in particular but it should make sense so when I create a row in my course registrations table, I name the column for the course model's id number course_id and follow the same for student_id.

So, that's it for now but tune it next time when I finally throw some code up to show how I would set up these tables.

Database models and ERDs for Newbs Part: 2

Kevin Steele — Mon, 21 Jan 2019 04:23:18 +0000

Recap from Last Time

So far we covered database models as a way to create abstractions that represent entities, or things with quantifiable attributes. Next, I'll explain some points on relationships and how we go about figuring them out.

What's Crow's Foot Notation?

Crow's Foot Notation can be traced back to the mid-1970s and something called structured systems analysis and design method if you want to do a little more reading after this. Essentially it's a way of diagramming entities as boxes and their relationships as lines with markings that roughly resemble a crow's foot. It also goes by the name of Barker's notation. With that bit of historical errata out of the way, let's get to the main point.

Why use it?

While we as developers are more than capable of creating amazing databases programmatically, writing code first leads to a lot of mistakes. Mistakes lead to greater cost and cost leads to things that can result in the failure of a venture or product. So just like carpenters, we need to measure twice and cut once. And by the way, you don't have to use this specific notation. Use any system that works to design your models and their relationships before you start programming. I'm personally interested in systems design and such, which is why I'm writing this.

What does it look like?

In action?

Let's unpack this.
The professors can have students but don't necessarily need to have students. Students need to have at least one professor. So imagine a small school that only documents their registered students. The professors may or may not teach a course but all students need to take at least one course to be counted at all for any kind of course credit. However, many-to-many relationships when implemented this way cause low cardinality, or having a lot of duplicated information. See the next figure.

Join tables to the rescue!

A join table is what it sounds like. It joins related tables and creates rows of matching entities. But, it would only contain references to them not copies to avoid low cardinality. In our case, we use course registrations to join our many students and professors.

Mind you we could still refine this to make an even better entity relationship diagram but that will have to wait for next week.

In part 3, we're gonna break this down even more to build a better system. If I'm able to, I'll be adding some code this time around.