General program thoughts for the end of October

Just a couple of thoughts while I work on refining Project 2 before submitting it...

It's been a week and a half since Project 1 was submitted. It has been taking the full two weeks to get projects returned, from what I understand. The review is very in-depth, which explains the time it takes for it to be returned. I'm hoping that doesn't get longer, though, as Udacity should be starting up a new cohort when November starts, and that will just be more work piled on top of the coaches, if additional help isn't brought in.

Through using git and GitHub during the first two projects, and reading through the resources on Udacity and GitHub itself, I've become comfortable enough to suggest changing off of SVN to git as our version control at work. I'm working up a presentation to use for pitching this to the boss, and I hope that it is as convincing as I think it is in my head.

I was really glad to watch Monday's Office Hours video. They started out by answering one of the biggest questions I had about Project 2 - why push beyond the expectations, to make a project completely Udacious? There is a real reason for it. It's not just to show you know the material, but to make your version stand out in the crowd and really express what you can do to a potential employer. I was concerned that going too far beyond the rubric would make it hard to tell that you actually did what was requested, but they are encouraging students to do just that. "Make it your own."

So, this weekend will be making Project 2 my own - and hopefully having my Project 1 review in my email box by then.

Javascript Basics and final project (for this specific class)

I just finished the lessons for the Javascript Basics course, and completed the project as designed throughout the course. I already knew quite a bit of what was taught in the course, as I had exposure to JSON through some of the Perl AJAX websites we designed at work, but I did learn some things that I didn't know about Javascript itself.

The most striking concept I learned was encapsulation. I had heard from my Java classes that "everything is an object", but I never considered functions to be objects of their own. I had always considered them outside the object realm. Having the ability to embed functions directly into the object itself, lends a sort of modularity that I had not though possible. Items which might have had global scope (and possibly caused issues with other functions using identical variable names) are instead put into a local scope, minimizing that possibility for error.

I still have a ways to go with this project, however. Although the project as it stands now meets the requirements of the grading rubric, it does not have the polish and "individuality" that the coaches are looking for. My project resembles the mockup well, so I know I have the basics covered. What I don't have just yet, are the extra bells and whistles (and from some examples I have seen, complete redesign of the layout) that is apparently becoming an expected part of the process.

With students posting their projects on Piazza for review, I wonder just how far beyond the mockup we can go, before the project is considered to be outside the expected results. For example, there is a student who decided to change the layout into a two column display. I admit, it looks tremendously good, and it has all the required elements displayed on the page. I just wonder where the line is between changing things to improve the look of the page, and going too far outside the box.

Javascript Basics course, through Lesson 1

I started into the Javascript basics course, and though I've only finished the first two lessons (Lesson 0 and Lesson 1, interestingly enough), I am not finding this class as polished as the others. My major concern, though, is the fact that I don't feel like I am learning what I need to learn during the explanation portion of the lesson.

I am used to classes that show you exactly what you need to know, and then let you practice that in the followup questions or quizzes. In this class, I feel that I am given a generic idea of what I need to learn, and the detail that I am supposed to learn comes in the quiz answers, afterward.

It may be intended that what we are supposed to learn is essentially pushed to the student's side, but it leaves myself (and several other students, from what I read on Piazza) with a lot of confusion and doubt that we are learning appropriately.

I had posted the following on the Piazza site, but for the sake of illustration, I have added it here:

For example, String Manipulation Quiz 1 gives a task of changing a string, and even gives a hint to use slice() in the instructor's notes. Why wasn't slice, or other string manipulators, presented in the lesson for students to understand? The "explain the details" approach was used in the Intro to CS class, so that students understood exactly what they were expected to use, and how to use it. For some reason, that approach is not used here. I don't know if that is by design, or just how it came out.

I found myself clicking on the box to get past the quiz, and learning more from the answer presentation than trying to use the information given before the quiz and hashing through it on my own.

I don't like being critical of the instructors, as I am sure they are putting a lot of work into these classes and presentations for us. Both instructors have been entertaining, and they do know their stuff. I just wish the presentation was more detailed, with more time spent on explaining exactly what the instructors expect you to know, and less on relying on the student to fill in the gaps.

Version Control - Git and Github

While waiting on the results of my first project, I went ahead and started the lessons for Version Control using Git and Github. I had started using Github on a different Udacity course (Make your own 2048), though I wasn't aware that Udacity had a class on using Git at that point.

I looked around for more information on using Github specifically, and though the documentation at Github's site is pretty good, I did find a quick course at CodeSchool on Git that was free. Unfortunately, the course there goes over the command line so quickly, that I really didn't feel like I had learned enough about it to retain the information.

When I started the Udacity course, I was relieved that the lessons were full of detail and did take the time to explain the different commands in such a way that I was able to really "get" the material, as well as practice using it.

I did not expect, though, that the GitHub portion would continue to use the git commands. From my previous work with the GitHub page, I expected it would be completely about the web interaction. Instead, the lesson correlated what I learned on the command line with the options in the web site.

One thing the course did not go over was the downloadable programs GitHub for Windows or GitHub for Mac. These programs basically allow you to do a lot of the command line work that is talked about in the lessons, and moves it into a GUI interface that works well to guide you through commits (including the ability to add commit messages without opening a separate editor) and looking at code differences in much the same way that 'git diff' does. This may have been left out of the lessons, in much the way that the HTML class talks about using IDEs as a tool instead of a crutch - the program simplifies the process, but you really need to know what is going on behind the scenes in order to use it to your best advantage.

Overall, like the HTML class, I have extended what I thought I knew well, and applied it in the projects each class presents. The training I am receiving in the nanodegree program is definitely making me feel like taking this series of courses is going to be well worth the time and effort.

First Project - Thoughts and Takeaways

I am now two weeks into the Nanodegree program, and today, I sent in the first project for review.

I started out by pulling up the Intro to HTML and CSS class that accompanies the project, as recommended, but didn't watch the class from beginning to end. I jumped around in the class, picking topics that seemed to be newer to me, such as the @media CSS and the semantic tags portions of the class, and skipped over the beginning CSS parts. I have been creating HTML sites for work for a while now, so I figured I didn't need to go through a lot of the basics.

Well, I was wrong.

My knowledge of HTML is still stuck in what I learned ten years ago about HTML 4. I had read about HTML5, but never really paid attention to it, as it didn't seem to be relevant at that time - after all, the web pages I developed worked fine in Internet Explorer using the HTML I already knew. I had heard of <canvas> tags, and other neat ideas - but none of that worked in the environment that we used at work, so I didn't pay much attention.

So, after finishing lessons 1 and 2 in the HTML class, I realized there were concepts and lessons that I would learn, even at this starting phase of the program. I think this is a good thing, as it shows me that Udacity does have something to teach me right from the beginning. This wasn't going to be a waste of time, trying to slog through the easy stuff to get to something new to learn.

I did learn that I have fallen behind in my self-taught web skills - and this program is going to correct that little flaw.

I jumped into working on the project. I created some DIVs, laid out some CSS, and promptly realized that I wasn't going to be able to create this project as simply as I had expected. The header would not line up, no matter what I tried to do. I went back to the lessons, and decided to use the flexbox CSS for aligning my page. After some trial and error, I wasn't getting the results I thought I should. A little more research turned up my issue, which was explained in the instructor notes: since I am using a Mac for my operating system, Safari requires a little more CSS for flexbox to work properly.

I did go back to the lessons to finish watching all of them. When I start the next project, I am going to watch each lesson all the way through, even though I have experience with JSON and JavaScript. There may be some basics to learn there, just as I needed to learn for this project.

The Piazza forums have been very helpful in getting a lot of questions answered. Seeing what other students are having issues with, has made it easier for me to know what to look for, or what resources are available for learning. The Flexbox CSS guide that was posted in Piazza helped me to clean up my code and get it working the way it should.

Overall, I think I have a better understanding of how I need to approach the projects, and that should help me to get the most out of this program that I can.

Almost forgot the important part: my first project submission!

Where to start...

What better way to show people how easy blogging can be, than to put together a simple one to show as an example, as well as getting my own thoughts down for others to read and comment on.

A little about me: I am 43 years old. I live in a little suburban town in southern Illinois, not too far from St Louis, Missouri, USA. I work for AT&T as a programmer, and I love what I do. Most of my work is centered around creating web tools and reporting for internal clients. This requires me to know some HTML, CSS and Javascript, but the majority of my work is done on the back end with Oracle databases and Perl or Java interfaces to that data.

My main reason for joining the Front End Web Development Nanodegree program is to strengthen my understanding of front end technologies, to help our team make the most responsive and well-designed sites that we can. From the looks of the program description, I should be right on track to do that.

I'm looking forward to what I can learn from the program, and hope that I can contribute back to the community in some meaningful way.