DEV Community: Sheldon Nunes

Should employers provide time for learning/training?

Sheldon Nunes — Thu, 24 Jan 2019 02:04:17 +0000

An excerpt from The Clean Coder by Robert C. Martin reads:

Your career is your responsibility. It is not your employer's responsibility to make sure you are marketable. It is not your employer's responsibility to train you, or send you to conferences, or buy you books ... It is also not your employer's responsibility to give you the time you need to learn. Some employers may provide that time ... they are doing you a favor, and you should be appropriately appreciative.

What do you think? Should employers provide learning time or is that something that should be done in your own time?

Exploring the Abstract Syntax Tree

Sheldon Nunes — Tue, 06 Nov 2018 07:20:27 +0000

Exploring the Abstract Syntax Tree

Hacktoberfest had me get out of my comfort zone and contribute to different codebases. One of them, a python linter gave me exposure using the python Abstract Syntax Tree.

What is an Abstract Syntax Tree?

An abstract syntax tree (AST) is a way of representing the syntax of a programming language as a hierarchical tree-like structure.

In essence we can take a line of code such as this:

pressure = 30

and convert it into a tree structure:

Wikipedia has a slightly different definition:

An AST is usually the result of the syntax analysis phase of a compiler. It often serves as an intermediate representation of the program through several stages that the compiler requires, and has a strong impact on the final output of the compiler.

So the AST is one of the stages towards creating compiled code. Definitely feels like we are getting closer to what the machine understands!

What this enables us to do is to step through the structure of a program and report any issues back (similar to intellisense/linters) or even change the code that is written.

Python provides a library for parsing and navigating an Abstract Syntax Tree and is aptly called ast.

Using the previous example we can create an ast by using the following command:

import ast
code = 'pressure = 3'
tree = ast.parse(code)

Simply printing the tree won’t display the structure and nodes that we want. Instead we can create a node visitor that will traverse the tree and give us details on each of the nodes:

class Visitor(ast.NodeVisitor):
    def generic_visit(self, node):
            print(type(node).__name__)
        ast.NodeVisitor.generic_visit(self, node)

Now if we create an instance of this visitor class, when we call visitor.visit(code) we will get the following output:

Module
Assign
Name
Store
Num

For a linter this is quite useful to see if any of these node orderings are invalid. A good example of this is when you have if True:… a redundant if statement since it always evaluates to the same result.

When we run visit on an if True:… we get the following:

Module
If
NameConstant
Expr
Ellipsis

In this case the True value is the NameConstant. The ast visitor allows us to create specific methods that get invoked when a particular ClassName is visited. This is achieved using the following syntax:

def visit_{className}(self, node):

In this case we are wanting to visit any If node and check it’s test condition to ensure that it isn’t just a NameConstant (True, False or None). This is where the ast documentation is quite useful as you can see what properties are available for each node type. We can access the node.test condition like so:

statement = "If statement always evaluates to {} on line {} "
def visit_If(self, node):
    condition= node.test
   if isinstance(condition, ast.NameConstant):
      print(statement.format(condition.value, node.lineno))
   ast.NodeVisitor.generic_visit(self, node)

Running this on our previous example gives us a nice detailed message:

If statement always evaluates to True on line 1

You are not limited to only ‘visiting’ a node in the AST. Using another one of pythons classes you can use ast.NodeTransformer to modify them too! This leads to really cool possibilities like inserting temporary lines of code to test code coverage of your program or even transpile to other languages

I recommend checking out the following resources if you are looking to make use of ast in python:

Green Tree Snakes - the missing Python AST docs

^ This one even includes a live web AST visualizer which can help see the code structure quickly!

Official AST Documentation

A copy of the code in this post can be found here

The next thing I would like to investigate is using the NodeTransformer to potentially transpile from python over to another language like Javascript.

Thanks for reading!
Share your experience/use cases for AST in the comments below!

How board games improved my ability to explain dev concepts

Sheldon Nunes — Fri, 26 Oct 2018 02:41:36 +0000

You glance at your watch anxiously; looking out the front door. “Come on guys” you mutter to yourself. The sausage rolls you took out the oven thirty minutes ago no longer hot. “Sorry we’re late” your friends say when they arrive. “No worries” you respond smiling, excited to catch-up with everyone. After a few hours of finding out the latest news and gossip you look at your watch again. ‘Time for the main event?” you propose. Mixed expressions form around the table. “Are you sure we will have enough time? I am pretty tired” someone says. “It will be fine, I have been looking forward to this all week!” you say dismissively.

Reaching under the table you slowly reveal the latest and greatest board game. You lift off the lid of the box as if opening a hidden treasure. While friends distribute the pieces amongst each other you reach for the sacred scriptures (the rule book). You call everyone to pay attention as you start to explain how to play the game. Everyone is attentive at first but as time goes on you start noticing some are drifting off into the boredom dimension.

“How about we start playing as it will probably make this easier to understand” you say in an effort to recover the night. Everything seems alright at first but then the questions start. “What is this?, How can I build that?”. You feel yourself explaining the same concepts again and again all the while friends look more perplexed. The group decides to finish the game early and heads home leaving you with cold sausage rolls and an incomplete board game.

Although board games are (usually) fun there is quite a large upfront cost we must pay to experience it. The dreaded setup and rules explanation requires everyone's attention to understand how the game works in order to play. This overhead is enough to put people off from deciding to play one in the first place. Video games differ in this regard as they are able to manage a lot of the complexity and expose only the interactive parts of the game.

Being able to effectively explain the rules of a game can make or break the experience. Here are some of the techniques I have found that work out really well and have changed how I explain any concept in my day to day life:

Start with theme or end goal

Games allow us to try and solve problems in an artificially constructed environment. Being able to sell the idea of what people are trying to solve is key to engaging with them. Let’s take the game Splendor for example:

Splendor board game

Compare the following:

We are each trying to collect the most victory points by collecting the most valuable cards

We are each competing gem merchants who are using our small supply of gems to build the most profitable empire.

Although these are both true descriptions of the game Splendor, the second creates an evocative theme that is immediately engaging. This leads players to ask “How do I become the most profitable empire?” which allows you to easily segue into the winning conditions. This provides the mind with a target/goal that is used to understand the relevance of the other rules or actions.

Give players the board game pieces

Giving players the opportunity to interact with the game pieces is an underestimated technique for engagement. It is easy to interpret someone playing with pieces as being distracted or not focused. However allowing players to interact allows them to form a connection with the game and pique their curiosity as to how a particular component is used.

Players asking questions

If you are like me you really engage well with content when being able to ask questions. My mind can get so caught up in wanting to know the answer that I don’t absorb the rest of the content.

When someone asks a question during your explanation you should always acknowledge it. This may mean choosing to answer it immediately, or alternatively that you will be answering it shortly in the rest of your explanation. Choosing which one of these options is up to you but be aware that answering a question too soon (before other required terminologies are understood) may confuse not only that person but others listening.

Applying this to the dev space

I have found these concepts apply quite nicely to software development. We typically create a nicely layered architecture that is ideal for the "explain backwards technique".

Setting a theme is relatively easy when aligning your work to your users. UX caught on to this idea a long time ago and create persona characters when creating designs to help establish a personality and motive for the thing they are helping create. For software development this often means we use User Stories or feature requests to help explain the “theme” of what we are trying to solve.

As an example if we were teaching an already implemented feature based on the following User Story:

As a florist I want to update an order to include or remove certain flowers

By starting here we are able to make a connection to this particular theme/domain and better understand the overall goal of the story. We could very easily have just called the florist a user and that would be fine, but provides a good frame when solving this problem. At this point it would be good to leverage the finished code and run through an example update order. However if this was not implemented yet you could use other techniques such as paper prototyping to describe the workflow for the user.

From this point more technical specifications can be created. This might be to update the orders record in the database. If I was explaining how this code had been implemented I would start at the database layer, move up through each layer until reaching the entry point of the application. This would allow the person learning to see the process gone through to reach the database form.

Explaining is an improvable skill. I hope that some of these techniques I have described help you. I have found board games to be a pretty awesome medium to do that and highly recommend giving it a try!

And as always curious to hear what you think? Have you had any hobbies that have influenced the way you communicate in dev?

Mini Quiz: Javascript Scoping

Sheldon Nunes — Mon, 08 Oct 2018 22:13:35 +0000

A quick quiz question on javascript scoping. Try and figure this out before executing in browser

If you were to create this object:

var person = {
    name: 'Dave',
    weight: 100,
    height: 180,
    calculateBMI: function() {
        console.log(this);
        function innerFunction() {
            console.log(this);
        }
        innerFunction();
    }
}

When running person.calculateBMI() what object will this be mapped to when logged by the innerFunction?

Hacktoberfest 2018 - Anyone looking for open source contributors?

Sheldon Nunes — Sun, 30 Sep 2018 21:31:45 +0000

I have usually only done the odd hackathon here and there and personal open source projects. This years hacktoberfest seems like a nice opportunity to start contributing back!

Does anyone have any projects they are looking for open source contributors?

Drop a comment below!