Contract Work

Showing posts with label deep thoughts. Show all posts
Showing posts with label deep thoughts. Show all posts

Friday, July 22, 2016

Remote Non-Senior Developers, Part 1: What Your Company Should Look For

When I tell developers I meet at conferences or elsewhere that I transitioned from a career in nonprofit management to becoming a software developer I usually get smiles. And then, when I add that since becoming a Dev I've only worked remotely, the smile changes to skepticism. I understand hat skepticism. People have views of what will help a junior Dev be successful, some companies have had bad experiences with non-senior remote developers, and there are lots more stories out there. But as remote work and distributed teams become more prevalent in the field, companies shouldn't feel like they can't hire, train, grow, and mentor less experienced developers as a result. Last month at the United Silver Spring Ruby meet up, I spoke about being a non-senior remote developer (note: non-senior does not explicitly mean junior although I was a remote junior developer). Folks of all experience levels were interested to hear what I had to say because many can't envision what a non-senior remote teammate might look like. Here's s little bit about my experience, what I think makes a successful remote non-senior Dev. Part 1 will cover what a company should look for when considering hiring someone and then part 2 (coming out next week) will go over what a less experienced developer should think critically about before deciding to go remote. 

I won’t lie to you. It does take a special type of person to be a remote worker regardless of their level. This is why some companies decide not to have remote employees at all. And it is a little riskier to hire a remote worker with less experience because do can have a higher risk of not being successful if they are not great (I say great because they do need to be better than good) at the things that make remote workers of any level good remote workers. Here are some characteristics you want to look for when hiring for a remote non-senior developer. 

  1. Someone who takes initiative. There are going to be bumps and issues and as a non-senior dev. In order for the employee to learn and grow as much as they possibly can, they’re going to need to make some decisions, put improvements in place, and get the rest of the team on board with what they need. Make sure that as a company, you look for someone who has done this in the past or has the potential to do this.

  2. Good communication skills. This is necessary for any developer but especially when remote. How can they articulate their thoughts, the research they've done, a problem they're facing, etc. 

  3. Learn about their past. Are they a new professional or just new to development? When I became a developer I had about 7 years of prior professional experience and had already been working from home for 2 years in different industries successfully. I might not be a senior developer technically, but I’ve got all the other skills necessary to be successful.

  4. Make sure the person understands what remote work is all about. Ask them about the best and worst parts of working remotely. I don't like working remotely because I can work in my pjs (which I don't do, for the record). I like it because I have a schedule, more work time without a commute, and a quiet distraction-free workspace. I also have opinions about the parts of working remotely I don't like. I’m aware of all the good parts and bad parts of remote work and I know what i’m getting into when I accept a remote position. You want to ensure you’re hiring someone who also understands these aspects or has at least thought through them.

  5. And maybe most importantly, someone who isn't afraid to say to a slack channel that they are stuck, frustrated, or need help. Without this personality trait, the individual won't be successful because asking questions is probably the most important skill a developer can have.

I find the best way to learn about all of the characteristics above is to ask behavioral interview questions. Instead of the interview where you decide if you'd like to chill with the candidate, ask about scenarios. For example, tell me about when you were stuck on a problem, what did you do? What if no one was available to help you? What was a time you had an issue with a teammate, how did you address it and how was it solved (if at all)? 

Now finding the right candidate is half the battle, but you also want to make sure they’re set up for success. A person isn't an island. They can only exist and thrive if they're put in an atmosphere to do so. Companies sometimes feel they don't have enough resources or structures in place to support a non-senior person but if you have the right candidate, you actually just need a few small things to ensure success.

  1. A good manager who has had some experience/training. This person will be vital for support and working through issues that may come up on the team. They should be an ally and be able to recognize when issues are actually opportunities to help the team as a whole grow and learn more about things like diversity, empathy, mentorship and more. 

  2. A kind, caring team. It is easy as a non-senior Dev to be scared of asking questions but if the team they are put on is supportive, thoughtful, positive, and constructive it will really go a long way in creating an environment with lots of psychological safety where it is easy to learn. 

  3. A system of regular check-ins. It's great if you have a good manager but that manager (or even a tech lead) need to be regularly checking in with this person, especially at the beginning. I think 1-1s are a vital part of a healthy team culture regardless of experience level or if folks are remote, but it’s even more important when you don’t see each other every day in person.

  4. A partially remote team. Even if your current team of remotes are only senior, having a partially remote team means you understand some of the baseline difficulties of remote work regardless of level. It also hopefully means you have some processes in place to allow for easy, async communication and remote pairing tools that are widely used and understood. I'm not saying it won't work if your first remote hire is non-senior but it's definitely going to be a steeper mountain to climb. 


That's it. Really not as involved as you thought it'd be, is it?

Here are the original slides from the talk I gave: https://speakerdeck.com/asheren/remote-non-senior-developers

Stay tuned for Part 2 next week.


And if you’re interested in hiring a remote software developer or want to speak more about the points made here, get in touch!

Monday, February 1, 2016

On what the heck to blog about


A few months ago, I made a commitment to start blogging again at least once per month. I keep this reminder on my to-do list and try to keep a running list of topics that I can write on. This WAS great when I had a lot of hours to put into extra learning, extra reading, and all those other great things you do when you’ve got more time. I blogged about side projects, issues I faced, interesting blog posts I’d read that week and a whole bunch of other things that I thought were pretty interesting.

Now that I have a small kiddo who periodically requires some attention (and by periodically I mean I looked away for like 5 seconds the other day to finish something and he totally face-planted), even more of my learning is done on the job. What I do at work is really interesting. The app is fairly complicated and so I new and different things every week. From feature builds to bug fixes to investigations, every day is varied. However, with all this learning i’m doing at work, and all the notes I take in my notebook so I can study and remember everything in the future, it’s hard to blog about these things. Why? Because there’s so much contextual knowledge around the problem and the solution. Aside from the fact that a lot of things are proprietary, you need to know a lot about the application, data structure, and history of development in order to understand why we need to solve some of the problems that we do. Furthermore, oftentimes what I am doing is a small piece of a larger puzzle since my tasks are often more digestible than whole large-scale tasks and to blog about this small piece would require a significant understanding of the larger component I’m working on. Finally, I still find it difficult to figure out which solutions are only applicable to that specific problem I’m solving and which are applicable to many different situations.


So, what do you blog about when you’re not working on a side project? How do you come up with ideas? I wish I could blog more often but I’m currently feeling like it just takes so long to figure out what to talk about!

Monday, June 16, 2014

One Giant Post about Ruby Nation



This year again, I attended Ruby Nation. This year was great because I actually understood what was going on!! Admittedly, I took better notes on the second day than on the first because I was speaking on the first day but most of the session I went to were really great. Also, I apologize in advance because this is just one giant post, as opposed to breaking it up by session which I usually do after conferences.

The first session was talking about ruby and government with Sarah Allen. She was recently a presidential innovation fellow and spoke a bit about the interesting things she was doing and the really interesting digital data issues that the Smithsonian system has. Sarah brought up some really interesting thoughts about rails in general. One of the most interesting (controversial?) things she talked about was making Rails more accessible. She talked about other platforms like Drupal or Wordpress and the ease of adding certain functionality or widgets there. These are things that Rails doesn’t have. It isn’t super accessible because you don't have the same sort of ability to add widgets or different features. Her point was that potentially being able to make it easier to add widgets would make us more effective programmers and that by doing this, we wouldn’t have to re-work things or add simple, commonly-requested functionality on a regular basis.­­

Her talk closed with three interesting points to think about. First, framework leads to language. Second, what if we could add UI features at runtime, and what would that look like? And third, non-developers are co-creators so how to we give them a more active role in rails.

The second talk was by Eileen Uchitelle and was about CRUD and ActiveRecord. I thought this talk was fantastic, although admittedly got a little lost in the middle. The premise of this talk was that when we assume activerecord is magic and does all these magical things, we end up not paying enough attention to our code and to the actual SQL queries and how they’re functioning. Eileen then went through an example using each of the CRUD methods (create, read, update, delete) and went through ways that the queries could be better, faster, and more effective. For example, in create, she spoke about batch insert and in read she talked about using pluck. Her slides are super clear and definitely worth a read.

The third session was Terence Lee speaking about working with Ruby. He spoke a lot about how to commit and encouraged everyone to get involved with fixing ruby, committing, and getting involved with the core team. I learned that .to_f is to float. Floating objects “represent inexact real numbers.” He talked about the future of ruby being focused on trust, transparency, and onboarding.

The fourth talk was given by Davy Stevenson on Ruby as science, art and craft. I thought this talk was really great and looked at code from different perspectives and points of view. She started with science, looking at algorithms and talking about what complexity looks like. Davy went through a variety of big O notation types like linear, quadratic, exponential, and factorial. She described an algorithm as a set of instructions that will solve a particular problem… a great definition for someone who isn’t a math person. She then looked at the convex hull problem and demonstrated different approaches through different algorithms that connect the points and show this convex hull in different ways. I won’t go into them here, but if you want to google them a bit further, she discussed brute force, gift wrapping, and monotone chain algorithms.

Then Davy talked about art. The art part was lots of imaged of different interpretations of art and thinking about them. The best part of that segment for me was a quote she mentioned from @sferik where he said that programming is about building powerful things in simple pieces.

Finally, Davy discussed craft taking the idea of apprenticeship and artisan abilities and connecting it to code. She said we write code to enrich our own lives and the lives of the people around us and then showed us examples of beautiful code. Definitely take a look at the slides to see what people consider as beautiful code.

After this was lightning talks!! There were a few talks… one on muscle driven development, which talked about health and treadmill desks. One on debugging, another on language and thinking about how the language we’re using shapes how we look at solutions. A fourth on Ruby For Good which is going to be awesome and everyone shold check out. The fifth was on the Angelo gem and the last talk was about how you shouldn’t do ops as a dev.

From here, we went into the tracks. Again, the talks today, I won’t do justice because I wasn’t focusing as much as I could/should have been but at hopefully I can provide some notes. The first session I went to was JohnPaul Ashenfelter’s Machine Learning talk. He did this at RailsConf as well (a longer version). It was really interesting. Basically, he spoke about different gems and things developers could use to learn more about the users. First, he talked about the sex machine gem which isn’t perfect but can help determine the gender assignment of your user base. Second, he discussed free geoip to show location awareness. After that, he got into clustering a bit and looking at clusters in order to help determine patterns. He walked through the ai4r gem which puts people into clusters and then calculates the centroid (centroid being the center of the random clusters) and finally, it loops through to see if users are closer to the center or their cluster or another cluster. This enables you to see what cluster people are in which is super helpful is your clusters show, for example, what tier users are paying for in your system. Alternatives to this can be hierarchical clusterers or divisive hierarchical clusterers. Finally, he talked about a gem called linalg and how you can use it for collaboration purposes (I think… my notes get a little sketchy here).

After that, I went to an ActiveRecord workshop with Dave Bock. This workshop is fantastic, but very hands on so not many notes. Basically, Dave has a handful of scenarios that each table has to discuss and talk about how they’d architect them. Really helpful for continuing to learn about ActiveRecord, associations, and modeling.

The next talks I went to was about tests and having a messy test suite. Presented by Chris Sexton and Aaron Kromer, this talk was great. They went through testing best practices and showed examples of clean, clear test structures. Some highlights were that you shouldn’t deeply nest state in your tests and you can fix this by creating contexts, this way the state is top level and you can test everything. Tests should help organize and expose state. Class declarations should tell what behaviors to test. Finally, the two most important pieces of advice were to prioritize what’s most important to test and then iterate towards that goal and make your tests better as you work towards your goal.

The last talk of the day was about sidekiq. I don’t have a ton of notes from this talk as well but presented by Mike Subelsky, it was a great walkthrough of sidekiq and what you can tell from the dashboard when running it.

Day 2
I was able to pay more attention on day 2.

Day 2 started with Jim Gay talking about east-oriented code. This is a pretty cool concept that operates under the principle of tell, don’t ask. The core of it is that queries travel west and commands travel east. The talked touched on the law of Demeter and talked about east oriented code being different than that. There are four things to keep in mind with east oriented code. First, always return self. In this way the method is prevented from querying, can only tell. It leads to polymorphism, duck typing, and encapsulation. Second, factories are exempt form this. Third, always follow rule 1. And finally, sometimes break rule 3. After rule four, he showed a really interesting rails erb template that described this and walked through it. I left this talk sortof understanding everything but definitely would love to take a look at the code examples and slides in order to comprehend it all a little further.

The second talk I went to was on two programmers in one. I loved this talk by Jano Gonzalez. He talked about how each of us as developers are a little hacker and a little thinker. The hacker wants to get things done, and quickly which can sometimes lead to a maintenance nightmare. The thinker thinks about maintainability, abstractions and all the different layers but sometimes can get away from the problem that they’re trying to solve and can have analysis paralysis. He then told his story about going from hacker to thinker and coming to a good balance with both sides when using ruby. Jano spoke about how the hacker is useful for exploring new territory but the thinker is good from defining components and acceptance criteria. Developers need to deliver value but also diminish technical debt and it’s all about the balance between the two. My favorite part of the talk was when he spoke about the 3 stages of learning from Martial Arts. There is Shu, Ha, and Ri. Shu is when you’re new and you follow all the rules. Ha is when you move on and start adding your own knowledge and breaking some of the rules, and Ri is when there are no rules to follow and no rules to break, you just do it.

After that was a talk on google glass by Lance. This was a fun talk and one I just sat back and enjoyed since I’m not really developing with google glass but was just curious. Lance talked about apps as service layers. He then went on to discuss some of the glass specs, things that are great about glass and things that still need to be fixed. He then talked about the Mirror API, which I still have to check out, and how you don’t need to know android in order to program for glass. There’s a concept of static cards which add functionality and a new(?) tool called WearScript which is a bit like phonegap for glass.

Interesting talk and really fun to just see some of the programming side of glass.

Sam spoke about the anatomy of a mocked call which basically involved doing a deep dive into what a mocked call means technically with rspec, using their internal mocking library. He started by talking about testing and why you test/TDD. His main points were that TDD’ing helps programmers create a mental model. It helps them think through what the code does and then because things change as you program, it helps keep that mental model intact and keeps you on track with the problem you’re trying to solve. In short, tests force behavior.

The first part of this deep dive was discussing stubbing. Stubbing is basically faking a response to a method. Moching enables you to verify the collaborations between objects by testing the methods that get called. It creates a mocked expectation. so in the example
it “does something” do
allow(foo).to receive(bar)
expect(foo.bar).to eq (nil)
end


The allow is actually allow= allowanceTarget.new

allowanceTarget is a subclass of the TargetBase and calls delegate_to on TargetBase and, with a setup_allowance, TargetBase defines TO as an allowancetarget enabling .to to exist as a matcher.

Then there is receive which is also often used as a matcher. Once receive is set up as a matcher, similar to how to is set up as a matcher above, then receive#setup_allowance creates a mock proxy. A mock proxy is an object that manages the metadata of mocks and stubs on the object in the lifecyce of a test. Calling add_stub on this proxy sets up a emthod double which saves the original implementation. Then calling foo.bar (the stubbed implementation) sends a message to the method double which sends a message to the proxy which invokes the stub which returns a value (gosh, I hope I got that right!).

When you run a test, rspec also runs setup and teardown before and after the test and at the end of the test, the teardown resets everything. This reminds me a little bit of how testing work in ember with quint.

Okay, now onto mocks. For explaining mocking, sam worked through the same example but using expect(foo) instead or allow(foo). In this case, expect = ExpectationTarget.new and goes through a similar process as the stub did, except this time with a mock. Here, once you have the proxy, the proxy callbacks checks to make sure the arguments are valid and the proxy raises if a mock wasn’t called.

Finally, I can’t remember at what point sam mentioned this, but during his talk (or when someone asked a question about using spies instead of mocks), he mentioned spies so now I know what spies are! Spies are whenever you do a a stub, it will record the information so you can set an expectation at the end of your test instead of at the beginning. Basically, you can set a spy to collect all sorts of information from you and when the object returns you can ask it questions about it’s experience. The way I envision this is similar to what the Dorothy’s were trying to do in Twister. In Twister, the tornado chasers weren’t able to learn more about tornadoes because they weren’t able to see or understand what was happening inside the tornado. They came up with a way to release thousands of little sensors into the tornado to collect all the information and have them transmit the information back so it could be recorded and studying. From my understanding so far, this is similar to what spies do.

Evan is great. He’s got so much experience and his talk was on remote pair programming. Now, I work remotely, so I’m familiar with a lot of the tools, but his talk was less focused on tools like madeye, nitrous, and screen hero and more focused on command line tools. He spoke a lot about vim and emacs (which made me really want to learn vim again… one day I’ll get around to that). He also spoke about tmux, ssh’ing into machines, and a lot of really interesting concepts. He spoke about how his remote pairing stack has changed over the years and different combinations of things he’s tried which allows people to pick any of these tools and configure it to their remote pairing liking. Overall, an interesting talk and some exposure to remote tools I hadn’t thought about in the past.

Mark spoke about wyriki which is a project that Jim Weirich was working on when he passed away. I’m gonna be honest and say that Mark lost me pretty early in his explanation but this is what I got. Wyriki is a different way to architect rails applications. It creates new structures of runners in between controllers and models which allow someone to isolate the business logic from everything else. The rest of my notes on this are sparse and it’s pretty obvious I got lost in there, but I think the core takeaway was thinking about different ways to structure apps, so not fat model, skinny controller and not everything in moderation but how to really separates different types of business logic in your apps.

Next up was Justin’s talk on breaking up with your test suite. I took frantic notes on this one and listened intently, but eve so I’m sure I missed stuff. Also, these slides were great and super understandable so check them out. So first was talking about why we should test. there were 8 or 9 ultimate reasons why code should be tested which fall into two essential categories. First, you can gain confidence from the test and you can gain understanding of the code through the tests. BUT he started by discussing that we should question before we test. When thinking about tests, we should think about the purpose, rules, and structure and we should expect that within our test suite these three items should be immediately clear to anyone looking at it. If we cram lots of different goals and motivations into each test, the test becomes unclear. The rules become debatable, the purpose becomes hazy, and the structure ends up being ad hoc instead of uniform. Every test suite should promote one type of confidence and 1 type of understanding. So, here are some different suites and for each suite Justin went through the user, what the understanding and confidence were, tips, and warning signs.

First up was the safety suite. The safety suite is for the browser It checks does the app work and is our product simple. If the tests do not fit inside 30 minute or if you can’t write a new test within 30 minutes then your product probably isn’t simple. These tests shouldn’t see the internal apis. They should bind to what is visible by the user and they should enforce a fixed time-budget. The warnings here are that failure from refactors are often false negatives here and that human intuition overvalues realistic tests. On this type of test suite, numerous releases and branches can get expensive and there is the idea of the superlinear slowdown meaning that the bigger the system, the slower the tests.

Next comes consumption tests You should verify behavior and demonstrate usage with these types of tests. The user is the repo’s customer and they are used to verify what you, as the programmer, is directly responsible for. It says, is this code usable? If it’s hard to test, it’s probably hard to use. For these the module boundaries should be meaningful beyond testing (ie- these things talk to each other so they should be tested together). It should fake all the dependencies. It should exercise the public, not private apis. And finally, it should be organized by the consumer’s goals and outcomes. Warnings-wise, these tests need to be fast and this is the only part of the suite that tells you “you just broke something”.

The next tests suite are contract tests. Contract tests are used by us. They represent our interests that live in someone else’s repo. It leads to faster feedback making sure that something in the system that someone else is working on, doesn’t break something you’re working on. For these, they should be written for first party dependencies and follow the same rules as consumption tests. These are NOT a replacement for actually going and talking to your fellow dev about what they’re working on.

Next is TDD. So, so far, in all these tests suites, none have talked at all about the design of the code. The main value in TDD-ing is to discover tiny, consistent bit that help with big projects. The user is someone concerned with implementation details and the inputs and outcomes. These tests are a sounding board and enable you to have confidence in building small things and learning about what roles our code is playing. Here, he showed a cool chart that had interesting structural points related to putting queries on the left, logic in the middle and commands on the right… reminded me a bit of east-oriented code structures. He also stated that commands and queries should have very little logic. The warning here is that discovery tests yield small disposable units so be okay with throwing stuff away.

Next are adapter tests (whoever knew there could be so many different kinds of tests suites!) These tests exercise the adapter API under just realistic enough circumstances. It warns us of outages or API changes. These tests also reduce the cost of swapping dependencies later. For these, don’t test them first and trust the framework. These are similar to contrat tests but contract tests improve communication between colleagues whereas these tests improve the feedback between your code and the 3rd party code. Last warnings are that these tests can be slow and outside of your control and that they can be tricky if you’re using some sort of CI.

Phew! that was that talk.

One note is that my confusion still lies a bit in integrating all of these different types of tests. Should an apps test suite have all of these things? What does it look like structurally? Are they in the same files or different files? But I think the idea of thinking about all of these different suites and the goals of tests and testing is pretty cool.

Production code analysis by Dan was a great talk. Dan talked about code cleanup and how to look at a monorail (single large application) and refactor/delete effectively. You want to look at what code is being run to allow for good code cleanup and that lots of these monorails have dead code. Some overarching tips are to celebrate clean up commits as a team and to start by finding large unused code sections by finding unused actions. There are a handful of tools he talked about to help find this dead code. First you can use new relic which can show you for any given endpoint, how often is it being hit and then you can do a route check to see what routes are completely unused. You can also use tools like graphte, statsD and redis to find unused actions. For example, statsD is pretty easy to implement, has lots of info from Etsy’s blog, and can be used to see both timing and emdpoint information. You can look at background jobs in redis to see which jobs aren’t being triggered at all and what events are related to those jobs.

For mailer, you can see which is the most popular and least popular mailers by hooking statsD into active mailer. Finally, if you find the actions not being triggered, you can often delete the related views that aren’t being rendered any more.

Another good place to look is at translations. Which translations are in memory but aren’t being used anymore? Use the gem humperdink to track these translations. Finally, you may have two methods that are doing the same thing in your code. For this, learn which is best by wrapping the methods in a split. Wrapping them in a split and tracking them with statsD will tell you which method is faster or more effective and allow you to make data-driven decisions.

Lastly, Dan talked about logs. Logs are great for cleaning up code. Logs should be searchable and in one place. You should try to standardize the log format and multiple apps that communicate should be in the same system. Once you’ve got good logs, you can do log queries or check out endpoints to see what’s arriving to them. For this, check out the gem imprint.

Russ Olsen spoke about going to the moon! Wait for this talk to come out on video. I had to leave about 15 minutes early which was a bummer but he’s such a good storyteller, I was on the edge of my seat the whole time.

Sunday, May 25, 2014

Interesting Reads 5/17 - 5/23

Lots of really great links this week. There are a few more RailsConf talks since I had a chance to watch a few more of those this week. Some great posts on terminal and keyboard shortcuts and tricks, and some fun team-related posts.

Enjoy!


Amazing tips and tricks in this post for keyboard shortcuts.

AND amazing tips for terminal in this one.

Leading a team is really hard. Jessie does a great job talking about some of the ways to actually be a GOOD manager.

Some great tools and thoughts for thinking from railsconf.

Love this! https://speakerdeck.com/aviflombaum/20-things-i-love-about-code

A really interesting talk about imposter syndrome

I've always looked at the stages of group development in the context of leadership groups and immersion experiences but this is an interesting post on the high performing team dynamic in programming

Does the size of a team affect the quality? This post talks about some of the data behind it.

Saturday, May 17, 2014

Interesting Reads 5/10 - 5/16

I have 8 RailsConf talks bookmarked to watch but I know I won't be able to watch all of them before posting, so I guess I'll have to include them in next week's roundup. That being said, below are a good handful of talks that I've already had a chance to watch and they are awesome so enjoy!

Coraline's great talk on apprenticeship: http://www.confreaks.com/videos/3346-railsconf-artisans-and-apprentices

10 years keynote: http://www.confreaks.com/videos/3337-railsconf-keynote-10-years

Reading Code good (but also is more about becoming better programmers specifically through this method of reading code): http://www.confreaks.com/videos/3342-railsconf-reading-code-good

In more personal news, I'm starting a new job next week!! I'm very excited to start at a new place but worried I'll be the weakest person on the team (a very common fear, I've been told). While I don't necessarily feel like a phony, I just feel new and still pretty inexperienced. This is an interesting read about how a lot of others feel similarly: http://www.hanselman.com/blog/ImAPhonyAreYou.aspx

I'm trying to start getting into hardware hacking a bit more and arduinos fascinate me, but I've had a hard time figuring out where to start. Ruby Rogues did a great podcast on hardware hacking! This was one of the super helpful resources: http://juliahgrace.com/intro-hardware-hacking-arduino.html

Friday, April 11, 2014

Interesting Reads 4/5 - 4/11

Some really good reads this week on a variety of different topics.

Enjoy!

Read on effective flows

Conference proposals and a good step-through process to create your proposal

Really in depth thoughts on crafting a talk

Improv and coding

Scientists and Code reviews

Write Code Everyday. I talk about this a lot in regards to learning to code. This post breaks things down really well.

Saturday, April 5, 2014

Interesting Reads 3/22-4/4


You'd think with two weeks of reading I'd have more interesting things, but not so much that past two weeks. The reads below are really good but I've been a little more heads down recently and haven't had the chance to read as much. Anyway, there are some good, interesting posts below, so check them out and enjoy!

Doing Your Best Work: http://www.naildrivin5.com/blog/2014/03/16/doing-your-best-work.html

The Last Developer was Terrible: https://medium.com/p/506a06ae35ea

Old but still interesting: http://rachelnabors.com/2012/04/of-github-and-pull-requests-and-comics/

A good first day: http://guillecarlos.com/developers-first-day-at-work.html

Monday, March 31, 2014

Other Great Things I Learned At EmberConf

As a newbie in development, I like to do a post on random things I learned during the conference. These often end up being CS terms, nerd culture related, or other interesting items that didn’t quite fit/make sense in a session post. Here are those from this conference.


Primitives: basic types in javascript like booleans and numbers.

Orthogonal: not a computer term, it just means adjacent.

Grok: means to really really understand something. It’s actually coined from a book about an alien and it’s understanding of humans. Check out the link to the book here.

D3 is a drawing library mostly used for graph’s or charts

Donut charts are pie charts with a hole in the middle

Truthy/falsy: this concept is more or less important based on the language. Basically, when stuff isn’t strictly true or false, javascript tries to help you out and guess which one it’ll be. A quick google search shows that there are lots of better explanations out there on what it is. This one looks pretty comprehensive and interesting: https://gist.github.com/jfarmer/2647362

CLI is a command line interface and it is how you interact with the app on the command line. (A perfect example of things I’ve been doing but didn’t actually know the name for)

This is a great background blog post that a few sessions referred to: http://emberjs.com/blog/2013/12/17/whats-coming-in-ember-in-2014.html


Finally, for other great notes from the conference, check out these links:

https://www.icloud.com/iw/#pages/BAKaAlrUjn9i0hXOyWyBDqAS2MEQFkyKTBaF/EmberConf_2014_Notes

https://github.com/zurt/notes/blob/master/EmberConf-2014.markdown

http://www.justinball.com/2014/03/27/ember-conf-2014-wrap-up/

http://pixelhandler.com/posts/we-are-emberconf-2014

http://hermanradtke.com/2014/03/27/emberconf-2014.html



Saturday, March 29, 2014

Ember Components transclude my directives


This talk was given by John K. Paul and I have to say, I learned A LOT during it. As I mentioned, components were mentioned a lot during this conference but this session gave me some interesting understanding of additional terms and a little bit of Angular.

In Angular, directives make custom widgets. They decorate existing HTML with additional functionality… essentially a piece of HTML and a piece of javascript. In directives, you can also restrict based on specific parts. For example, restrict E means restrict based on an element, restrict C means restrict based on a class.

Transclusion is the inclusion of one thing into something else. Directives are used for making a DSL in your HTML but in order to do that, there are lots of knobs and levers and you need to understand lots of stuff to make that happen. For example, you put transclude: true in a directive definition which takes whatever is inside the element and moves it into the html where “ng-transclude” is written.

Ember’s got something similar to directives and those are components… except that components are much cooler and much easier to understand and create. An ember component is a custom component that you can use in many different places. The more general form of this are web components which are discussed in the extensible web manifesto (more on that in a later post) but it is basically rolling your own reusable widget. Ember components let us do something like this now and allows us to encapsulate HTML, CSS, and JS. It lets us package together a structure and behavior.

An example John K. Paul used was ember tabs, which are also ember components. They’re reusable. More examples are x-tabs and x-pane. The best thing about components is that you can take this functionality that is encapsulated in this component and just copy and paste it into your code, change very few things and have it good to go in the app you’re working on. The last slide talked about ember component lists that Eric Berry (http://coderberry.me/) and John K. Paul (https://gist.github.com/johnkpaul/6796944) have been putting together and urged other people to add to it as they create components. I, for one, think a collective list like this would be amazing and I’m very excited to use components more and experiment with how to use them to make us more productive and make our app better!

Wednesday, March 26, 2014

Being a Healthy Programmer

Health issues. Something we all face as developers but is not really talked about. Being a developer comes with some very specific health concerns that are different than what I’ve experienced in other fields. As I’ve learned to code over the past year, I’ve gotten a lot of advice and learned a lot of best practices. None of this advice, however, has included anything related to health! All of a sudden, I was coding full time and experiencing all these new issues and I had no idea why. We all experience similar physical pains of transitioning into a new industry but it's one of the things I think isn't discussed adequately enough to prevent it from happening. Additionally, a lot of the solutions cost money, which may be something you don't have a lot of if you are going through a career transition, coming out of a bootcamp, or just in the beginning of your job. In speaking to others, I found that most of the stuff I was experiencing are really common among developers. I sent out a request to understand what people experience and what some solutions are and here’s what I got.


Eyes. Obviously looking at a screen that is two feet away from your face all day has got to have some serious long term effect. Additionally, if you don’t have the right prescription then you’re also probably dealing with some sort of eye strain.

Back. Posture and sitting up straight is really important. Long term affects can include needing physical therapy, surgery or just constant pain.

Headaches. I know a few people (including myself) that have been experiencing afternoons headaches. There are LOTS of things that can affect headaches including hydration, food, eye strain, muscle aches, and more.

Hydration. Turns out we all forget to stay hydrated during the day. Between coffee intake (which actually dehydrates you) and getting so focused on work that we forget to make sure we’re drinking, this is a major issue (that can, of course, relate to other things on this list like general draining, back pain, and headaches).

Food. What?! You forgot to eat again? Me too! I can’t even count the number of times I’ve looked up from my computer and realized it’s 2pm and I haven’t had breakfast or lunch yet. Obviously, not a healthy practice.

Sleep. “Just 5 more minute and I’ll be able to solve this issue and close my computer.” I’ve said this to a friend or my husband so many times. We tend to try to power through problems, drink coffee or energy drinks to push that last bit of code to production, or just accomplish a little more by working through the night which is solid, uninterrupted time. This is also related to something someone called “sleep creep” (which I love). Instead of working through the evening, some developers will get up at 4:30am, have some solid morning work time and then have to check out for a bit in the afternoon for a nap or to recharge.

Weight Gain. We sit. A lot. Like all day. There are lots of ways exercising can affect other things on this list, but weight gain and circulation from sitting all day can definitely be harmful and a tough pattern to break out of.

General draining. What we do involves a lot of brain power and a lot of thinking. It is easy to get exhausted and it’s easy to finish the day and just want to get the easiest thing for food and sit on the couch to unwind. This isn’t so much a solution, but a good article that goes into this issue further.

Hands. There’s lots of concern about repetitive strain and carpal tunnel syndrome. This is definitely an issue that, as a newbie I don’t think about much but as someone getting started in a longterm development career, I probably should.

(Thanks to @vicfriedman, @pamtaro, @embryoconcepts, @robyurkowski, @tundal45, @stevenhaddox, @_ZPH, and @peterbroderick for your help and mentioning issues you’ve faced or are concerned about)

So, how do we improve out situation? It’s great to offer solutions like a standing desk, complex raised screen setup, and other such tools but these tools are expensive! Here are some cheap ways we can solve these issues.

“Pretend” standing desk. My first standing desk was literally 3 boxes stacked on top of one another to give me computer a little bit of height.

Pomodoroing. Following the pomorodo work style basically means that you do focused work for a specific amount of time (usually 25 minutes) and then you take a mandatory break for 5 minutes. There are lots of benefits to doing this but I find that it makes me more aware of myself. When I have a forced break, I make myself drink water, use the restroom during the break. I also find that when I break every 25 minutes, I’m way more aware of my posture and actively correcting my slouchiness.

F.lux. This app helps alter your computer screen lighting based on the time of day. I wasn’t so much a believer until I started using it but the gradual deletion of blue light from your screen helps you mind get ready for sleep even if you’re still using your computer.

Posture exercises. This is one a friend passed along to me. I also recently saw an app that focuses on alerting you when you aren’t holding good posture.

Exercise in general. I’m lumping standing versus sitting into this category as well. Exercise is always tricky to make time for but it is definitely an important part of being a developer (I reluctantly type as someone who really hates going to the gym). Put GYM in your calendar.

And finally, there’s the Healthy Programmer book which I haven’t read at all, but I’d bet it’s pretty informative.

I’ll be honest, I’m not the best at following all of these. I haven’t found good boxes to make a standing desk, I only successfully pomodoro’ed once in the past 3 weeks, but being more aware of these issues motivates me to make sure I’m establishing best practices for my health. And of course I’m hoping in the near future to be able to purchase the things I need to make my home office and work situation even better (ie- the chair I use is like the worst chair for programming EVER).

Got more issues, suggestions, and cheap alternatives? Leave them in comments below.

Saturday, February 15, 2014

Interesting Reads 2/7 - 2/14

Yes yes yes, I owe the world a more interesting blog post than just interesting reads, and I've got a bunch in the works! In the future, you can look forward to the last post on the gem, a post on ember, a random learnings post, probably a post about my first few weeks as a professional programmer (which have been crazy and amazing and exciting and scary and pretty much all the emotions) but for now, I have to just give you the interesting reads for the week. Hopefully you find them interesting as well.

Enjoy!


Yes! This! Tech and Tiaras

Software Developers Changing Lightbulbs

Thoughts on Working Remotely

I don't agree with all of this but there are some really interesting points made about how everyone shouldn't learn to code.

A Year of Code. Similar to the piece above.

Friday, February 7, 2014

Interesting Reads 2/1 - 2/7

Well, it certainly has been a busy week for me. Fortunately, I've also come across some really interesting articles and things to read/watch. AND I've actually read all of the articles this week (except for the last one... it's a video I haven't had a chance to fully check out yet). There's a variety of stuff in here this week so ...

Enjoy!

Will NOT Work for shoes! I love shoes, but this is a great article about women and their workplace value.

If you've had a rough week or are a newer developer, this short post is a great pick-me-up.

Personally, I'm not very good at celebrating small wins. That, coupled with the fact that I'm getting used to a "dev" to do list, as opposed to a non-dev to do list, makes it hard sometimes to feel like I'm accomplishing greatness. This post talks about that and some great ways to reflect regularly on your work.

Okay, I lied!! I haven't had a chance to read this article about the amazing new Marvel API, but I've gotta find time soon!

On a slightly dryer note... here's some great HTML5 documentation.

In my new position, I'm learning Javascript... lots of Javascript, but Ember.js in particular. Since I'm new to it, I thought this article gave some interesting, basic pointers about the differences between some of the more popular JS languages.

A great post from Aaron based on a question asked at RetroRuby's Newbie track last week!

And to close out this week, here's a video I haven't watched yet about Postgres and things you haven't found.

Saturday, January 25, 2014

Interesting Reads 1/18 - 1/24

This week I started working with Purpose! Working with them this past week has been really interesting and really wonderful... BUT it means that I've currently got close to 80 tabs open covering things from "new stuff to learn" to "things to read" to "things to watch". So... I have definitely not had a chance to read everything on this list yet, but they all seem like excellent pieces for the week.

Enjoy!






Ruby Conferences! (not an article but a new awesome site)

Monday, January 20, 2014

Contributing to OSS

So, if I haven’t said it enough, getting involved in the community is crazy important. I’ve recently been looking for a job. The process has actually been more difficult than I anticipated. A lot of people will tell you it’s incredibly easy to get a job in this field. I’d say that while there are positions available in the field, it is still challenging to convince a company, especially as a newer developer, that you are worth it and that you’ll totally blow them away… if they just give you the chance. Additionally, I want to make sure that where I end up is the right fit. I feel fortunate to have years of professional experience that have allowed me to really know myself as a professional and give me a better ability to determine if a company is a good fit for me or not.

While looking for a permanent position, i’ve been looking for great, challenging projects that continue to expand my skillset and make sure I’m learning as much as possible while I have the time. A few weeks ago, I was approached by a friend at a meetup who had a little too much on his plate and felt he had some work that would provide me with some good experience. Because he’s a friend, he knows my level and therefore I’m very comfortable asking questions. He also thought this project would be a good one because he could provide support, the gem needed to be built but isn’t super crazy complex, and he felt it could provide me with a good opportunity to contribute to OSS… something that is on my goals for this time period and definitely something I’ve been looking to do. Conversely, as a solo freelancer, he hasn’t had the opportunity to often pair or to take part in code reviews, a skill he wants to develop. We saw this as a win-win situation and there I was... working on a ruby gem. The gem posts are a little post-dated because I wrote them as I was working on the gem but didn't have a chance to post everything!!! So, I'll try to get these posts up quickly.

The gem has some simple functionality. It is essentially a way to work with a company’s API and download additional information about email blast campaigns beyond what they currently provide. The gem involves writing tests, utilizing an http client, and working with the API.

I have to admit that a large portion of me is/was terrified. I’m building something new. I’m actually getting paid to do it. AND it’s then going on the interwebs… as a gem… and a part of OSS… for other people to use!!! But fortunately, I’m not terrified enough to shy away from the opportunity.

Geoff had gotten me started by giving me access to a private repo, creating the gem structure, and providing a few details and resources he had thought through in regards to the gem. I started by creating the spec file and thinking through what this gem would do in order to write some tests that could be used essentially as an outline. I put all these tests as pending, but I was able to scope out the major functionalities by thinking about what the output would be and what we would need to make sure is working.

I then started on the actual code. I started by taking the tests and looking at what classes those would create. Classes should each have a single responsibility so I looked at each action that needed to happen and thought about a class structure based on that. My intention is to write the code all in the same file and then do some refactoring to break it up. The next step was looking at the http clients. There is an authentication component to this gem and once the authentication happens, a cookie is received and that cookie needs to be stored in order for it to be used in future actions.

Monday, January 6, 2014

Cooking and Coding


I’ve been playing around with this post in my mind for a while. See, one of the things I’m truly passionate about is cooking. I love to cook and I love to bake… each requiring a slightly different mentality. For those who do either, you understand the differences.

Cooking is oftentimes about getting into the kitchen, opening up the fridge and throwing some things together. There is tweaking that goes on along the way. You might add some more salt, or usually in my case a dash of cumin. You might substitute one ingredient for another. Sometimes the concoction is great. Other times, you watch it sit in the fridge because it didn’t turn out quite right.

Baking is a little different. There is a preciseness to baking. You need to measure and create the product according to the instructions. In baking, there are very few places where you can or should deviate from the given recipe. For example, my high school chemistry paper was on the chemistry of cooking. Even simply adding ingredients in a different order will give your product a completely different texture or volume.

For me, baking is my calm, happy place. It’s what I do when my brain is in overdrive and I just need to pound some dough, get my hands dirty with flour or batter, or just focus on bringing each of the pieces together.

The more I code, the more I think of how my journey mirrors that of me learning how to cook and bake, and how different parts of the coding process are exactly like cooking versus baking.

When I began learning how to code, it was hard. It was difficult to motivate myself to do something I wasn’t comfortable with. It was difficult to wrap my brain around all the pieces. I always wanted to see a picture of the final product and know what the final result was supposed to be before getting started. Furthermore, I only followed recipes. I had no ideas what spices went together or when I could substitute one ingredient for another. I followed the recipe to a T and if I didn’t have a spice or an ingredient… I gave up on the recipe and searched for something else to cook. Cooking also took me longer to get through because I wasn’t familiar with the process. The first time I deboned a chicken piece or roasted a squash, I needed to read the instructions a few times because I felt lost at the initial direction.

Once I started to become confident about my cooking, I was able to get better much faster. I cooked a few times a week and I didn't dread it. Cooking more often made my knife skills better and my prep time shorter. Additionally, it made me more adventurous. I was no longer afraid about something not turning out exactly like it should. I substituted ingredients based on what was in the fridge and created meals from my mind and not necessarily straight from the cookbook.

I’m still not a master chef. I never will be. I hope to continue to flex my culinary creativity muscle as I cook more and learn more. Each time I add a new ingredient or a new recipe into my repertoire, it teaches me about flavor profiles that belong together and how I can mimic that with other ingredients. Just like with coding, I am still honing my ability to figure out when something is just right… the right balance of flavors and textures.

Every code involves some cooking, some sense of does it taste right? Does it look right? Does the texture look good? Is it pretty? And what do others have to say about how I could improve the recipe in the future?

Now for baking. As I mentioned before, baking is precise. You need to have a gut feeling about baking. Do you add a little more flour? What happens if you throw a pinch of nutmeg into the mix? Does this dough feel right? And if it doesn’t, what alteration should I make? It has taken me a while to develop my baking gut feelings. When you screw up baking, it’s often a bigger disaster than with cooking. It’s easier to cover up mistakes with spices and other ingredients when you cook but when you bake, sometimes you don’t know something went very wrong until you pull it out of the oven. Other times, you know something doesn’t feel right but you’re not sure what the best way to make it feel better is. And sometimes, the best thing to do is to just punch and knead it for a little while.

I imagine I’ll develop my baker’s sense for coding as the years progress and in writing this, it makes me feel like testing and practice test driven development relate more to the baking side of coding than the cooking side, highlighting it’s importance.

Regardless of whether you’re baking or cooking or coding, all get better with time and practice. All give you raw ingredients that you intelligently mix together to make something better. And all provide you with challenges, problems, and hopefully, wonderful solutions.

Now, go grab a snack and get back to coding.

Friday, January 3, 2014

Friday, December 27, 2013

Interesting Reads from the Week

I'm trying something new. I'm going to try to post interesting articles I've read (or meant to read) during the week every Friday. These articles/talks/blog posts/etc. may not have been published this past week, but it means I read or watched them this week. I'll try to also post who I heard about them from, but I didn't note that this week, so it'll be just the things I read for now.

Enjoy!

The Taxonomy of Terrible Programmers

Pairing vs. Code Review

Sublime Text Tips and Shortcuts

The Unreasonable Effectiveness of TDD

How Developers Stop Learning: Rise of the Expert Beginner

Tuesday, November 26, 2013

Are you good code or bad code? - Day 3, Session 4

This was the last session of the conference but fortunately, also one of the most fun sessions! The session was moderated by Matt Aimonetti and featured a panel discussed if bad ruby code exists. The panel was comprise of Aaron Patterson, Bryan Liles, and Bryan Helmkamp. If you have a chance, WATCH THIS TALK! As opposed to being a presentation, it was actually a really interesting discussion. I have a few notes from this session that I’ll write below but a lot of the conversation was mostly about questions to ask yourself as a developer when you’re writing code. Additionally, the panel members talked about their perspectives on good code, bad code, get it done code, etc. Overall, they were all really good points for me to continue to keep in mind as I work on different projects and in the future, work on more complicated projects.

First, there was a discussion about what is good code. The consensus seemed to be that good code was more testable, more maintainable, and more extendable. Most people seemed to settle on the fact that there is no bad code, but there definitely is code and better code. To this point, Bryan from Code Climate talked about the static analysis of code which helps people make more informed decisions. He hopes that the code climate process is helping to make better coders and also help determine what is better code.

Second, there was some discussion of “the rules”. I found this really interesting since I’m still learning the rules and the rules are important. When you’re first learning, it’s important to know the best practices and what the rules are. The goal is to get to a point where you can decide in an educated way if you want to break that rule or group of rules and why.

A question came up about refactoring and when you should take the time to look over your code, refactor and make those changes. The panel discussed always asking themselves the question of “how long would it take me to take this code and make it easier/better?” (easier/better meaning easier to work with or in). When the answer is around a week or longer, you’ve probably gone too far without pausing to refactor.

One suggestion based on this is when you’re working in a class, decompose the things into composed methods. In other words, factor out methods into smaller methods.

But seriously, watch this talk. It was entertaining, humorous, interesting and I feel like made me a better developer in a very different way than most of the other sessions.

The most important things I took from this talk:
1. Good development is knowing why versus how
2. A good developer knows the rules and also knows when to break them
3. Write the best code you can in the time you have
4. Focus on moving forward. Be a better developer today than you were yesterday, be better this year than you were last year, and so on.

Monday, November 25, 2013

Keynote: Code StoryTelling

The third day’s keynote was pretty interesting. Ernie Miller was talking about writing code and particularly writing ruby. The main premise of the talk was that your code should tell a story. In order to tell that story, things should be clean and clear. I learned lots of new terms and extensions of terms I already knew. A good way to tell the complexity of code is through branching. Branching shows how complex code is by showing how many branches it has. Branches are determined by places in which code could go more than one way. For example, an if statement counts as a branch because it shows code choosing one path or another.

Earlier in the talk, he spoke about rules of class macros. Classes should be easy to understand, order independent, free of branches, show what and not how, and idempotent. He also talked about callbacks. I didn’t previously know that there were so many different types of callbacks. There are reverse callbacks, around callbacks, and skip callbacks.

The final term I learned was prepend. Prepend relates to include and extend, but different. Prepend is related to include but in include, methods on the class are a higher priority than methods included from modules but prepend changes that! When you use prepend, the priority order changes so you can say prepend A for example and then A would be a higher priority than the other methods in the class.

Obviously this talk had a better flow than the notes presented here. He went over a lot of different ways to write ruby and styles. I just took notes on the terms I didn’t know previously and wanted to look into after the talk. Fortunately for everyone, the slides are up! https://speakerdeck.com/erniemiller/thats-not-very-ruby-of-you