Wednesday, December 30, 2015

Thoughts on teaching Java at home

My son is taking his first Java programming course in high school (an Advanced Placement [AP] course).  Since I am primarily doing Java work most of the time now, I figured some father-son bonding would be fun to do while teaching him some Java stuff.  The result so far has been fun at times and I think he has learned a bit but also causes me to pause to think about the timing and process a bit along with other items. 

Some thoughts/considerations/findings are:
  1. I question how much I should try teaching him in this situation.  Part of my reasoning revolves around the fact that his class is moving pretty slow (maybe the memory of how slow my first Pascal course was has faded) and the content is somewhat limited with focus mainly around the requirements of the final AP test.  I don't want to distract him too much from his teachers plans due to the chance he may not focus enough on the exam requirements.
  2.  I've never taught anything formal before and have no training as a teacher.  This in and of itself makes things difficult but I find it even harder when combined with how long I have been programming (using Java and other languages).  All my knowledge and experience helps me in day to day work but I find it hard to identify material at an appropriate knowledge level for someone just starting out. It seems that teaching someone that already knows the language fundamentals should be easier than starting from a nearly blank slate. There are three major areas where I run into this.
    1. Language features/syntax
      1. Try explaining functional aspects of Java (lambda functions) to someone that is just finishing talking about 'for' loops in class.  If you come up with enough examples you might get past the initial glassy-eyed stare but it will take a while.  I am thinking that after his current class, many of the more interesting ideas should be easier to grasp or at least provide an easier basis to start explaining things.
    2. Data structures
      1.  I work with reasonably complex problems and utilize many of the of common collection classes constantly. In examples for my son, I am finding it hard to limit myself to simple arrays.  I keep getting drawn into explaining the fundamentals of data structures along with the various collection classes.  Unfortunately, my main goals usually are not about data structure fundamentals.  It is almost funny as I pondered how to explain Java references and I keep wanting to utilize C/assembler/machine details to contrast them [aka pointer, memory address].  This may work if someone already knows C or understands the underlying hardware (things like Von Neumann or Harvard architectures) but I found myself on a slippery (but fun/interesting) slope trying to find the appropriate wording.
    3. Examples and Design considerations
      1. Coming up with an extensible example that starts like "Hello World" and gradually includes new language features/syntax while demonstrating (reasonable) design skills is likely harder than my day job.  While I may cringe on occasion at examples my son has from class, I am starting to understand why they are needed at times.  It is more effort and time to teach design skills concurrently with language syntax and usage.  I would love to come up with a really nice example program/project idea that scales from day 1 all the way through the Java 8 changes AND demonstrates a reasonable design strategy.  Maybe something like that is possible or already exists but I don't have the time to create or find it.
Another impediment which I wouldn't have anticipated as one is the use of an IDE (Integrated Development Environment).  I use Eclipse about 99.9% of the time.  In the high school class they don't use anything more than Notepad++ (and just plain notepad at times).  The impediment in this case is not their use of Notepad++ but my reliance on Eclipse.  I find that when I work on some toy ideas with my son (not using an IDE), I do miss silly mistakes now which would be obvious as you type in Eclipse.  With code completion, I don't usually have to memorize the specific order of parameters for most things, etc.  If you take away the code completion, it does slow things down and I find myself providing parameters in the wrong order at times and making other mistakes.  The problem is obvious when parameters have incompatible types but otherwise it does take extra time debugging that type of problem.  Debugging and analyzing error messages are good learning tools but it is somewhat an annoyance when that isn't part of what you are trying to demonstrate.

If I was a real teacher then there are surely many resources to help with planning a real curriculum but doing this type of thing mainly spur of the moment is not easily done.

Now that I mentioned a number of impediments, I should mention a few resources which I think have helped teach my son (and maybe my daughter later).  I think a couple old "Java in a Nutshell" books helped a little - he can thumb through them as needed and put bookmarks anywhere he desires.  I think an even better resource is my Java 6 certification book/study guide.  I don't think he has spent a lot of time with it yet but the fact that it contains oodles of correct/incorrect small code samples with descriptions of why they work or not should be a big plus.  If he starts at the beginning, with a little effort he should be able to pick up many of the individual concepts presented.  I probably won't quiz him with the sample test questions though.  It make take him a while to mentally put it all together but I think it could be a really good start.  If he digs into it more thoroughly I will document what i find.
 
The following is more of a side note related to myself.

On that note, after giving my son my Java 6 certification book/guide, I went ahead and picked up the "OCA Java 8 programmer I" and "OCP Java 8 Programmer II" study guides.  In the past, I had considered taking the tests but just never found enough time to fully prepare (cram for realistically).  There were API's that I rarely, if ever, need/use that I would need preparation (Threading comes to mind).  And my earlier comments regarding reliance upon an IDE like Eclipse resulting in a bit of laxness in reading what I write still applies.  I'm not a real fan of reading intentionally misleading and ugly code but I understand reason for it in the context of the certifications. Even so, the study guides are still really useful though because they do tend to describe things which might be uncommon but useful or items which you may have forgotten about.  I'll admit here that I had somewhat forgotten that you can specify "default:" in a "switch" at a location other than the end of it.  I, as a standard practice, always specify it at the end of the "switch" - I don't remember the last time I specified it anywhere else.  So the study guides provide good examples of valid syntax which you may not utilize due to existing organizational code standards or similar reasons.  There are also items covering new features which you may not be (highly) familiar with. 

I'm going to put more effort into actually getting the OCA certification in the near term.  I think this will be a wise choice related to employment over the next 4-6 months.  Hopefully I can find time for the OCP certification as well.  It appears to be increasingly import to differentiate oneself from others.  I just don't want to take away too much family time in the process.  Some prayers will hopefully help in setting priorities. 

Thanks for reading,
Scott

No comments:

Post a Comment