All posts by Adrian Tillman

How to get hired as a developer without job experience

developerSo you want to become a  developer.

You have worked really hard for the last two (or four) years, hitting those books and writing code.  You have the Java certifications and degree in hand. Now you are tirelessly searching the job boards for that first job. Unfortunately, every employer keeps asking for “experience” but you have none. What is a coder to do?

Let’s talk about how you can get a competitive advantage in today’s job market.

Certifications and proficiency

First and foremost, let us talk about those certifications.

The truth is that employers are not interested in whether or not you are certified. That’s not to say it doesn’t have value. The value lies in the fact that to obtain the certification, you had to demonstrate a proficiency in Java that most students cannot say they possess. This is to your advantage. Make sure you list that at the top of your resume, but do not count on it being the sole reason you get a job.

Do I need job experience?

Let’s address the experience factor. Experience can come in many shapes and sizes. Most students take it to mean that they must have job experience. But this is not always true. In many cases, I have hired individuals who have participated in open source projects and contributed significantly to them.

What is an open source project? Developers often have side projects that they want to do for fun or as a contribution to the developer community to help solve problems.

Node.js is one of those open source projects. I am quite sure you have heard of Linux as well. Yep, you guessed it, open source.

So, seek out an open source project and contribute. Not only will you gain experience. Many of the developers hosting these projects are more than willing to help guide and mentor a young developer. If you are interested in finding an open source project to contribute to, the first place you will want to look is GitHub.

Github: An interactive approach to becoming a software developer

Now, that brings up another point. Get on Git!

GitHub is a tool for source code control. It allows multiple developers to work and share a project in different locations. It is more than that though. GitHub is a community of developers.

One of the hardest things when vetting a potential candidate is determining whether or not they can really write code or the quality of their code. Enter GitHub. GitHub allows us to search a candidate’s language interest and their activity as well as see code examples. Sure you have that cute portfolio in which you posted your assignments. However, programmers are not interested in this. Most hiring managers do not have the time to go download some third party tool and check out your code. Most, however, understand GitHub and have access to it because they use it daily to host their own company’s source code.

So, if you are on GitHub and have contributed source code and I see it on your resume, this is to your advantage.

In today’s job market, competition is fierce among graduating students. To get your resume noticed and increase your marketability, you have to make yourself stand out from the rest of the group. Following the steps I have outlined will greatly enhance your chances of becoming the next Rock Star developer.

Oh yeah – if you are interested in an open source project with me, please e-mail me at Tillman.Adrian@spcollege.edu. I’d love to have you.

 

Robotics Club generates interest for SPC technology students

SPC professor Adrian Tillman starts Robotics Club.
Adrian Tillman

Interested in joining St. Petersburg College’s Robotics Club?

Clubs are one way the College of Computer & Information Technology (CCIT) strives to stimulate student interest in information technology. One professor who is piloting a Robotics Club is CCIT Professor Adrian Tillman. Tillman has been with the college since fall 2011. Previously a lead software engineer and developer in the public sector, Tillman brings a wealth of technology experience to SPC students. He has also acquired experience working with desktop applications, where he configured mobile devices and dealt with a host of programming languages such as PYTHON.

Robotics Club sign ups

Though many expressed interest, thus far three students have signed up for the Robotics Club: Erick Bravo, Andrew Case and Jerome King. They are among several students who receive tutoring for programming courses with Adrian Tillman at the St. Petersburg/Gibbs Campus on Friday afternoons from 1-5 p.m.

These three SPC students recently joined the Robotics Club.
From left to right: Erick Bravo, Andrew Case, Jerome King

“I think Professor Tillman is the best instructor. His involvement with students and his depth of knowledge inspire me to learn more,” said Erick Bravo, who is enrolled in the Computer Programmer Certificate Program at SPC.

Jerome King, who is also pursuing an IT degree agreed with Andrew’s sentiments. “I am in my first course for computer programming and I feel that this is just the start of what can carry me leaps and bounds and sharpen my critical thinking skills,” he said.

This is not the first time a launched club has garnered great interest in information technology. In fall 2011, CCIT Professor Brad Yourth of the Clearwater Campus introduced a Computer Club. The club was designed to help students explore computer programming languages, programming robotics and X-Box games.

Tillman is very enthusiastic about the progress of the club. He plans to involve students in more club events in the future. For more information about the Robotics Club, contact Professor Adrian Tillman on twitter at @proftill or email him at Tillman.Adrian@spcollege.edu.

Top tools for becoming a professional developer

Now that the holiday season has come and gone, I know many of you have holiday cash that’s burning a hole in your pocket. Wait a minute. Before you go out and buy that new pair of Air Yeezy sneakers, how about making an investment in yourself first? If you plan on becoming a professional developer, you will have to do more than just study what is given to you in school. I will quickly run through my top five books that I believe belong on every beginning developer’s bookshelf and hopefully, you will run out to your nearest bookstore and grab a copy for yourself. Without further ado, here we go.

Code CompleteCode Complete 2, Steven C. McConnell

I like this book because it teaches you how to write code. The question is, can you write a “good” code?

This book goes through all the considerations you need to make while writing your code to greatly improve it in terms of maintainability. I also love the checklists that the author includes in the book.

 

Clean CodeClean Code, Uncle Bob Martin

This book is of interest since it is about software craftsmanship. It will introduce you to a couple more advanced concepts that weren’t covered in Code Complete. It is a very easy read. You will find yourself referring to it over and over again.

 

 

 

The pragmatic programmerThe Pragmatic Programmer, Andrew Hunt and David Thomas

This book is great since it will give you a bunch of tips on how to master your craft. It will introduce you to some more advanced concepts such as aspect-oriented programming and domain languages. What I like most about this book is that it has a list of other books you should read to support those concepts. You will really be able to build a great library from the books you find inside.

 

The art of unit testingThe Art of Unit Testing, Roy Osherove

This is a good book about writing solid code via unit testing. Unit Testing is an approach that goes hand-in-hand with writing clean code. Most companies that use an agile approach will want you to understand how to write unit test and this book is helpful with that concept.

 

 

Domain Driven DesignDomain Driven Design, Tackling Complexity at the Heart of Software ,  Eric Evans

Domain Driven Design (DDD) is everywhere in the industry. This book is a good read since it will teach you more about architecture and layering and how to understand the layered approaches that most architects are taking these days. This insight makes it easier for you to navigate through the code in complex systems that you will work on.

I hope you find these books useful. If you have any questions about some of the content you may find inside, feel free to email me at:

Tillman.Adrian@spcollege.edu  or contact me on Twitter: @proftill

Honorable Mention:

RefactoringRefactoring, Improving Design Code, Martin Fowler

Design Patterns, The Elements of Reusable Object Oriented Software, Erich Gamma, Ralph Johnson, John Vlissides, Richard Helm.

Images courtesy of Amazon.com.

SPC professor warns parents about baby monitor hackers

St. Petersburg College technology professor Adrian Tillman was featured recently on WFLA discussing how to prevent people from hacking into your baby monitor.

Tillman warns that using strong passwords not tied to your name or birthday is one way to lessen the risk of baby monitor hackers.

He also recommends securing your wi-fi and setting up a firewall as ways to deter hackers from accessing baby monitors and security cameras.

Link to the video below.

Adrian Tillman

Paradigms: An innovative avenue to coding

St. Petersburg College has certificates and degrees to prepare you for a career in Computer Programming. Believe it or not, there are different ways of writing programs. We often refer to them as paradigms.

Generally, we will classify them as imperative (Procedural and Object-Oriented) and functional. Most of the programming languages that are familiar to many, are mainly imperative, I.e. Java, C#, and Python. However, the functional features are being increasingly added to these languages.

An imperative language is characterized by code that changes the values of variables as the program executes. We refer to the variable values as the state of the program. Essentially, the goal of an imperative program is to manipulate the state of variables until some desirable outcome is reached.

On the other hand, functional programming eliminates the concept of state. Instead, we think in terms of functions and evaluations of those functions. We write programs by composing functions and making larger functions from them. Let’s look at an example of procedural code. Consider the problem of summing all the even numbers between 1 and 10. We would write the following procedural code:

total=0

for n in range (1,11):

if n % 2 =0:

total +=n

print (total)

Here our goal is the total and we constantly manipulate the state of the total variable until we reach our goal. Notice that we didn’t use any objects as a part of our code. Now, we can rewrite our code and make use of the object oriented features of Python.

evens=list()

for n in range (1,11):

if n % 2 =0:

evens.append(n)

print(sum(evens))

In this snippet, we create a list object to store our even numbers and then we reiterate over the range, by adding the even numbers to the list as we find them. At the end, we pass the entire list to the sum function.

The two code examples both produce the same result. However, instead of changing the value of the variables directly, the second version manipulates the state of the list object. WE could take it a step further and enclose the code in a class that inherits from the list and add a sum method to that class.

Without going too much in-depth into functional programming in this blog entry, I just want to give you a quick taste. We could write the same code using Python list comprehensions like the following:

Sum(n for n in range (1,11) if n% 2 =0})

Now, we are no longer manipulating any state. This version of our code is also more readable. We eliminated all the boilerplate code associated with the loop. This allows us to express our program in terms of what we want more so than in terms of how to do it.

I hope this has peaked your interest in functional programming. This is one in a series of blogs about coding. Stay tuned for more!

An Inside Look at Java programming

Among the certificates offered by SPC’s College of Computer & Information Technology (CCIT), Java programming is at the top of the list.

Upon completion of CCIT certificate programs,  students may choose to continue for industry certifications.

Java programming video series

In preparation for such certification, SPC Professor Adrian Tillman is putting together a series of videos that explains Java programming . This is the first video in the Java Programming series.

An Inside look at Python Counter

What we learn in school is just a tiny fraction of what is available to us as programmers. My goal in this series of blog posts is to introduce you to some of the more advance topics of several different languages. In this post I will talk specifically about the python collections Counter class.

The other day I was writing some code to analyze a dataset. The data contained a dictionary of records representing bit.ly link data. A record looked like the following:

{u’a’: u’Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.78 Safari/535.11′,

u’al’: u’en-US,en;q=0.8′,

u’c’: u’US’,

u’cy’: u’Danvers’,

u’g’: u’A6qOVH’,

u’gr’: u’MA’,

u’h’: u’wfLQtf’,

u’hc’: 1331822918,

u’hh’: u’1.usa.gov’,

u’l’: u’orofrog’,

u’ll’: [42.576698, -70.954903],

u’nk’: 1,

u’r’: u’http://www.facebook.com/l/7AQEFzjSi/1.usa.gov/wfLQtf’,

u’t’: 1331923247,

u’tz’: u’America/New_York’,

u’u’: u’http://www.ncbi.nlm.nih.gov/pubmed/22415991′}

The letter immediately following the u is the key. So this line, u’tz’: u’America/New_York’, specifies that the time zone for this particular record is ‘America/New_York’. Most of the records contained the ‘tz’ field and a corresponding time zone value. I was attempting to list the top 10 time zones that appeared in the data. The approach you learned in school would involve looping through the data and collecting a count of each. Let’s say we had extracted a list of our time zones that looked like the following:

In [42]: time_zones[:10]

Out[42]:

[u’America/New_York’,

u’America/Denver’,

u’America/New_York’,

u’America/Sao_Paulo’,

u’America/New_York’,

u’America/New_York’,

u’Europe/Warsaw’,

u”,

u”,

u”]

Then we could do something like this:

def get_counts(items):

counts = defaultdict(int)

for x in sequence:

counts[x] += 1

return counts

Here, I’m creating a dictionary of int values. A dictionary is basically an object that stores values by key. Next, I’m iterating through the sequence and every time I encounter a new value I increment the value corresponding to that particular x by 1. So let’s say I had the following list.

student_grades = [‘A’, ‘A’, ‘B’, ‘B’, ‘B’, ‘B’, ‘C’, ‘F’]

The code would begin by reiterating over the list and x would become ‘B’. The counts[x] += 1 line of code would look in the dictionary for a key called x and then increment it’s value by 1. Since this is the first time we have seen an ‘A’, the value for ‘A’ in the dictionary would be 1. Now the loop continues and x becomes the second ‘A’. When the counts[x] += 1 line is encountered, the value for ‘A’ is already 1 so it will become 2. The x value would now become ‘B’, and since there is no ‘B’ in counts, it becomes 1, then 2, and so on.

I would use the code like this:

cnts = get_counts(student_grades)

I can then get the count for a particular time zone like this:

cnts[‘B’]

Which would return 4.

If I want to get the top ten I could do this:

def top_counts(count_dict, n=10):

#n = 10 gives me a default value for 10 if the caller does not specify one.

value_key_pairs = [(count, tx) for tx, count in count_dict.items()]

value_key_pairs.sort()

return value_key_pairs[-n]

Python Counter list comprehension

This code begins by using a feature of the python language called a list comprehension. I’ll do a separate blog on those later. We’re extracting the keys and values from the dictionary and them storing them in a list. Next we sort that list and then we use a slice to count backwards from the end of the list, returning n items from the end.

That codes not so bad but we can save ourselves a few keystrokes. In the same library as defaultdict, collections, there exists a class called Counter.

We could shorten all that code to this:

from collections import Counter

counts – Counter(time_zones)

counts.most_common(10)

Giving us:

In [43]: counts.most_common(10)

Out[43]:

[(u’America/New_York’, 1251),

(u”, 521),

(u’America/Chicago’, 400),

(u’America/Los_Angeles’, 382),

(u’America/Denver’, 191),

(u’Europe/London’, 74),

(u’Asia/Tokyo’, 37),

(u’Pacific/Honolulu’, 36),

(u’Europe/Madrid’, 35),

(u’America/Sao_Paulo’, 33)]

Whew, that was so much easier. Always explore your language to see if there is something that will solve your task easier. Don’t reinvent the wheel! If you want to find out more about the collection library visit https://docs.python.org/2/library/collections.html.