Photo Source My Summer break has been wonderful and although I'm sad to see it go, I'm also extremely excited for what this Fall Semester has in store.  School starts tomorrow for me and I wanted to do a quick recap of what I was able to accomplish this summer.  I published an aggressive To-Do list earlier this summer and I thought it would be cool to see how much of it I was actually able to accomplish :) Here are the items that I wanted to accomplish this summer: Unity 5 Training & C# Learning Swift for iOS Learning Android Studio Blender Maya UX Design Foundation Sass Here are the items that I actually accomplished this summer: Learning Swift for iOS Learning to Test Code Effectively Practicing Data Structures + Algorithm Design Sass Foundation Speed Reading Techniques Memory Enhancement Techniques PHP Wordpress Development As you can see, I took some liberties with the list that I originally intended to complete. Mid-Summer, I felt that I needed to work on my foundational learning abilities. I have always had issues with my memory and I take copious notes to overcome that issue. I have also always had the desire to read more rapidly, although I never really thought that I could effectively become a "speed" reader, I discovered that improving my reading speed is actually a goal that I could reasonably accomplish. Since these are baseline skills, I felt that it was a great idea to work on them before the new school year began. Learning to test my code more effectively fell within the same category of foundational learning, because I felt as though enhancing this skill will be beneficial for my current internships and future ones as well! Although I didn't quite get done what I originally set out to do, I was still able to end my Summer break with a decent set of new tools that will help me along the way!
End of Summer Recap

Take a Look
I often like to read through some of Google careers information for insight into what I should be focusing on learning while still in school.  Recently, I stumbled upon Google's Technical Development Guide, targeted towards Computer Science students that are looking to get a job at Google.  This guide gives online supplemental resources for students.  In my opinion, this guide is intended to ensure that CS students understand that they will not likely be successful while relying solely on school curriculum to gain the knowledge necessary to be a developer. Let's take a peek at what they suggest... To say the very least, this guide is extensive with action items ranging from taking an Introduction to CS course to learning Artificial Intelligence, to learning Parallel Programming.  Their list seems to approach being a well-rounded developer from two angles: 1) Gathering technical skills and broadening programming language knowledge and 2) Gaining experience working in team environments and on teams outside of usual school structure. What does this list entail?
  • Take an Into to CS Course
  • Code in (at least) ONE object-oriented programming language (C++, Java, Python)
  • Learn other programming languages: JavaScript, CSS + HTML, Ruby, C, PHP, Perl, Shell Script, Lisp, Scheme. 
  • Test Your Code
  • Develop logical reasoning and knowledge of Discrete Math
  • Develop a strong understanding of algorithms and data structures. 
  • Develop a strong understanding of operating systems. 
  • Learn UX design
  • Learn Artificial Intelligence
  • Learn how to build compilers
  • Learn Cryptography
  • Learn Parallel Programming
  • Work on projects outside of the classroom
  • Work on projects with other developers 
  • Practice your algorithmic knowledge and coding skills
  • Work on a small piece of a large system (code base), read and understand existing code, track down documentation, and debug
  • Become a Teaching Assistant
  • Gain internship experience in software engineering
You may be thinking, "this list would take a life time to master".  In many cases, that is the truth, but I think the goal is to have a decent understanding of all of these areas then use that knowledge determine an area to master.  For instance, I plan to specialize in Artificial Intelligence in grad school, but it's still important for me to understand the other areas because they all work together.  Regardless, this list gives us a glimpse into what Google expects from future Software Engineer applicants.  Google accompanies their list with links to online resources that students can use to accomplish these tasks.  I've highlighted in blue the tasks that I have worked on since beginning my CS degree program.  I did this to demonstrate just how obtainable this list is, especially when tackled over time. Bottomline...  I believe the biggest takeaway in this situation is that students shouldn't rely solely on their school's curriculum to give them all of the knowledge they need.  I have been an advocate of supplemental learning and have mentioned it in many blog posts before this one.  What's more interesting is that supplemental learning has gone from being a way to be competitive while job hunting, to being an expectation for many successful organizations.  As technology advances, developers will need to have a broader skill baseline in order to be successful.  Personally, I believe this Technical Development Guide is a tool that any aspiring developer should use, not just ones that want to snag a job at Google!
Want a job at Google? Google’s Technical Development Guide!

Take a Look
It's that time again... the usually dreaded time to return to classes.  This time around, I have mixed feelings regarding the start of my final Fall semester.  On one hand, I am holding on to the tiny bit of my summer vacation.  But on the other hand, I am more than excited to begin this semester, if only because of the classes that I will be taking this time around.  Here's my Fall semester lineup:
  1. Data Structures and Analysis
  2. Computer Systems Architecture
  3. Linear Algebra
  4. Advanced Programming Languages
  5. Object Oriented Concurrent Programming
I also plan to supplement my learning with a couple of free MOOCs:
  1. Algorithms 1
  2. Software Testing
As usual, I have piled my semester with tons of fun and plenty of things to learn.  This semester will be special to me because I will be taking the bulk of my Computer Science core classes.  As I took some time to re-read the course descriptions, I could feel the excitement rising because much of the gaps I've felt lately, will be addressed this semester. Let's discuss these "gaps"... A huge part of my studies has been self-taught.  Although I am attending a university in order to get my degree, a large portion of what I know now, has come from countless hours of practice, reading, and completing MOOCs online.  While stumbling working my way through my self-learning, there have always been areas that I felt would have been more clear had I gotten to that point in my formal education.  Or, in many cases, the resources available teach a watered-down version of a subject, which left gaps in general understanding.  In these situations, I found myself seeking different sources of information to fill in the gaps, but sometimes, the information still was elusive at best. I know that school will not fill in all of the gaps, but I do feel as though this semester will provide me with a more in depth guideline to follow in order to deepen my understanding, specifically around data structures and algorithms. So, onward I go to my next to last semester of school!  
Back to School: This Semester’s Classes

Take a Look
If you follow my personal blog, then you already know that I started tutoring about a month ago.  Tutoring has been a rewarding endeavor and I can see me continuing to do it as long as I breathe.  But with tutoring comes a lot of confusion in the techniques used to teach newcomers to programming, such as pseudocode. Pseudocode has its place in technology...  The only time in my studies have I found pseudocode to be useful has been in my software engineering course.  In this course, pseudocode was used to explain snippets of code to executives and customers so that they can get a feel for what the  program would do and to get a bit more technical without using actual code.  In these situations, syntax is not as much of a concern as getting the functionality across to the client. Where pseudocode doesn't belong is teaching people how to code... I understand the desire to take baby steps to teach newcomers how to code.  We do not want to overwhelm them and have them running for the hills before they have even gotten their feet wet.  But I wholeheartedly believe that using pseudocode fosters more confusion than necessary.  I tutor students from 4 different Intro to Algorithm and Design classes.  Some professors have their students translate their code from pseudocode to C code and have them practice it in an IDE.  I find that these students often mix the syntax between the two and it leaves them more confused. Where is the breakdown? In one class, it's like learning two different languages.  If pseudocode is to be used, I personally believe that professors should chuck syntax out of the window.  Let them type whatever they want, as long as they understand the concept, who cares if the student types "Set count to zero", as opposed to "count equals zero".  Let them get the concept that they have to assign a value to a variable without the added issue of worrying about syntax.  Pseudocode should not be it's own language, in my opinion.  Why? because it varies across text books, and even in the same class, it's taught in different ways.  Also, a student can not run pseudocode to check to see if what they did was correct.  For the first week or two, let them logically write out what steps they are taking in the program without fake syntax.  I have found that since they are so caught up on syntax, they skip over the logic generating portions of coding because they are so worried that their professors will take off points from fake code. I suppose I believe that pseudocode is helpful, but only when used as a logic-generating tool in order to get the student thinking about their program without focusing on syntax and actual code.  The other part of learning needs to be using a language that is easy to use.  There are many languages that I think would accomplish this.  I like Python, personally, but I don't care what the language is really, as long as they are learning syntax with an actual language.  An actual programming language should be used to teach the syntax portion of learning to code, not pseudocode.  By using an actual language, the student has access to a developer's API to use as a learning resource.  They should be allowed to learn while using a language that can be compiled in order to get immediate feedback on their errors.  An actual language should be used so that students can do web searches and watch tutorials in order for them to solidify concepts in the way that they learn best. Bottomline Using an actual language to teach syntax is best because the student is then able to play around in an IDE, make changes, and get a feel for how programming works.  Pseudocode, more times than not, leaves students more confused and frustrated.  It was no surprise to me that students were able to pick up on using C much quicker than using pseudocode, and it's not because they learned pseudocode first.  They were more successful with using C, because they were able to get feedback from the compiler, research online, and use developer documentation to correct their errors.  
Using Pseudocode to Teach?

Take a Look