Career Mentors (Bye Jay)

Today my manager Jay is leaving. It was a massive shock when I found out. As he’s the CTO I had two thoughts:

  1. “Oh no, I’m sad now”
  2. “Is the company in trouble?”

So in fact, he’s making the decision to go purely because he wants a new challenge which is completely understandable and I wish him the best of luck.

He has been the best manager I have had so far because he’s been supportive, encouraging, and an ear when I need to moan (which can happen often as I am very picky particular dedicated to delivering a great product). He also doesn’t just tell me things I want to hear (which is pretty rare in people). I get honest answers and opinions.

Being a woman in tech, I didn’t have many people to look up to in order to steer me in the right direction, getting me to where I am now. I have done it all by myself (which makes me proud now that I think about it) but it’s been exhausting.

I haven’t had someone else to give me their wisdom which would’ve undoubtedly meant that I probably would’ve made less mistakes along the way. But from the beginning Jay has given advice, let me feel like I can research everything that will help improve the team and the area that I work in for the company, has given me autonomy, let me attend the events that I want (through which I have met some great people), sends me Twitter links to awesome women in tech (like @TheAmyCode) for further encouragement, and in general has made me feel more confident about being in this role and that I deserve this role because I am awesome.

Find A Career Mentor

It’s important to find people like this to guide you through your career because no matter whether you’re male or female, careers are hard and a little guidance goes a long long way.

If you do find these people, make sure that it’s not just a one-sided relationship. Make sure that there’s something that you can give them too. Whether it’s small things like being self-sufficient so that they don’t need to worry about you or giving back something tangible that could help make their lives easier or better.

So, bye Jay. See you soon, it’s been great working with you and remember BBQ!

 

How to Future-Proof Your Testing Career

Last week, my latest post was published on Simple Programmer.

This post talks about the ways you can make sure that you stay employable by learning about different areas of the tech industry.

Earlier this year, I won a scholarship to use the A Cloud Guru video tutorials platform. Since I use the AWS Cloud Computing Services platform daily at my current job, I thought it was a great opportunity to learn more about it. And luckily I got selected. So this year, I intend to future proof myself by learning about cloud computing.

Here’s my latest post for Simple Programmer, How to Future-Proof Your Testing Career.

My First (and the) First Appium Conference

Last year, I was selected for a scholarship to Appium Conference 2018 by White October Events. I’ve been aware of Appium for years now as I’m an app developer but I’ve not (yet) used this tool on any of my projects.

For those that don’t know, Appium is a mobile testing framework built upon the Webdriver technology. It was created in 2013 by Dan Cuellar. He was an Test Manager at Zoosk who  was finding that the length of the test passes on the iOS product was getting out of hand. Appium allowed him to write automated tests for iOS as easily as Webdriver was used for automating websites.

Five years later, Appium has a massive community building up a successful open source project that can be used on Android, iOS, Windows in a variety of coding languages.

This year was the first Appium Conference.

There was only one track which was great because I got to see everything and didn’t have to pick between two talks that were probably going to be beneficial to me.

Interesting Things to Note

  • There was a lot of variety of languages being used with Appium (part of the appeal of using the product I suspect).
  • Lots of people were using Jenkins with it as their continuous integration/continuous delivery tool. There were a couple mentions of Circle CI but none about TeamCity. Because of this, I think I’ll be looking into Jenkins more than TeamCity for my app projects.

All the talks were highly interesting and not too difficult to follow for a beginner like me. So I want to share my biggest takeaways from each of the talks.

Keynote – Appium: The Untold Story

The day began with a keynote from Dan Cuellar and Jason Huggins. They spoke about the history of Appium, where it is now and briefly touched upon where he wants it to be in the future and mentioned their vision of StarDriver.

They want to see Appium grow it’s users and the platforms it can test particularly to the internet-of-things and various hardware.

The best takeaway for me from this keynote was the phrase “Challenge everything you see”.

Appium: A Better way to Play the Game

This first talk was given by Charlene Granadosin & Charlotte Bersamin. What I found interesting within their talk was how they were integrating their release and exit reports within Jira using Xray. They used a curl command to upload their latest test results to Jira so these results are clearly visible to the Product Owners or Managers of the team.

My biggest takeaway from this talk was to investigate whether the tools we were currently using for test case management was able to integrate with Jira to give such detailed reports and to try and get the automation up and running.

Deep Hacking Appium for Fun and Profit

Daniel Puterman‘s talk explained how he had contributed to the Appium project by creating a new endpoint to gather native application screenshots.

Because the company Daniel worked with was Applitools, my biggest takeway from this was to figure out whether visual testing tools would be useful for testing virtual reality (VR) applications as much as they would be for websites of mobile applications.

Why the h# should I use Appium with ReactNative?

Wim Selles delved into a comparison talk about why they chose Appium (which was extremely useful as I’ve also been debating what automation tool to use for mobile apps).

Out of all the frameworks he mentioned, they went with Appium because it fit with a lot of his requirements for testing ReactNative apps.

There were a lot of takeways for me from this talk.

  • Consider your own project requirements when you pick your automation tools
  • What are your requirements?
  • What should your app do (now/future)?
  • Which tool supports your needs/expectations?
  • Do a proof of concept test
  • Do research into competitive tools

He also gave a couple of good ways that you can speed up app testing:

  • Remove animations on screens
  • Utilise deep-linking to get directly to screens

Layout Automation Testing (GUI)

Prachi Nagpal explained how she was using Galen to perform her UI browser based testing for mobile and desktop devices. Galen does this by measuring the distance between elements that are being tested. You can also produce heatmap results from this tool.

It was a good talk and interesting to see a tool that I had never heard about.

Can you please provide the full Appium Server logs? A Brief Tour of the Logs

Isaac Murchie next walked us through the Appium logs and the takeaway here was that he pointed out that some lines are bolded to highlight their importance.

He also noted that the following are ways to know which are requests and responses in the logs.

This is a request:

[HTTP] -> 

This is a response:

[HTTP] <-

Interaction with Native Components in Real Devices

In his talk, Telmo Cardoso told us how he tested native components of mobile operating systems. He explained the challenges that he faced (some tasks were difficult on one platform but easier on the other) and ways he and his team had got around them.

The areas he found challenging were:

  • Adding contacts
  • Pushing files to a device
  • Push notifications
  • Managing calls
  • Simulating low battery
  • Extracting logs

The biggest takeaway from this talk was that he used Cucumber for his automation framework along with with Appium successfully to test the native applications and features of smartphones and not just the applications running on them.

Using Appium for Unity Games and Apps

Because of my daily work with Unity projects, I was particularly looking forward to Ru Cindrea‘s talk on how she used Appium for her Unity games and apps.

She first explained how she used OpenCV an image recognition tool with Appium to try and test her Unity games.

The positives were:

  • Works for simple scenarios
  • No changes to game required
  • Found issues like performance issues or out of memory crashes

The negatives were:

  • Wasn’t fast enough
  • Not for games with lots of text

So she decided to create a component called AltUnityTester to help her with her issues.

AltUnityTester is created with Python bindings. It opens a socket connection and waits for a response on a specific port.

When the AltDriver is added into the Appium project it gets a list and knows everything about that Unity scene’s objects. It can then send a command to that port to get information back from the scene to perform tests e.g. checking the end position of elements or text output.

This solution is useful because it’s real-time but it does require changes to the project and it only works with Unity.

So my biggest takeaway was to investigate whether this AltUnityTester could be extended or something similar made in order to test VR applications using Unity.

It’s available as a Unity package or on Gitlab.

Docker-Android: Open-source UI Test Infrastructure for Mobile Website and Android

Application

Budi Utomo next talked about his Docker-Android image to test Android projects and websites on Android devices.

His plan for project development was to:

  1. Create UI tests for Android devices
  2. Write unit tests on Android
  3. Create UI tests on Android apps
  4. Implement Monkey/Stress tests

The biggest takeaway was the demo that showed how Appium can be used easily within Docker containers.

Application Backdoor via Appium

Rajdeep Varma explained how you can use Appium scripts to call development code methods from test code.

He used Appium in this way because he was having a number of problems when trying to write tests:

  • System pop-ups were called and were not needed when running tests
  • Driver limits e.g. mocking the device has been shaken or changing time limits
  • Tests were slow to run

This is where he is using backdoors and where he thinks they could also be used:

  • Changing backend URLs
  • Changing app locale
  • Getting session ids from the app
  • Disabling “What’s new” pop-ups
  • Disabling client side A/B tests
  • Faking SIM card for payments
  • Get analytics data from the app to validate it

The biggest takeaway from this talk was to be careful not to use backdoor for every test case and call incorrect methods in order to make tests pass.

Mobile Peer 2 Peer Communication Testing

Canberk Akduygu gave us a talk about his challenges when automating the BIP app (it’s like the Turkish Whatsapp).

He was building an extended grid solution to change to the right version of Appium and set the desired capabilities within their testing framework according to properties set in a JSON config file.

His demo was the biggest takeaway which showed two phones messaging and even calling the other. It was one scenario that was running two different steps on each device. It showed that the test steps needed to be synchronised.

From a Software Tester to an Entrepreneur: What I’ve Learned

Kristel Kruustuk next came on stage and walked us through why she founded Testilio and her struggles with the company despite being so successful and growing at a fast pace since she began.

My takeaway from this talk to was investigate and get in touch with the Testilio team and see if they had any future plans for expanding from manual and automation testing to VR testing.

Appium: The Next Five Years

Jonathan Lipps gave the final talk and began again with the history of Appium but then spoke more in depth about the vision of the product over the next five years and hopeful milestones. Some of these things were:

  • StarDriver
  • InfinityDriver
  • Extension to the W3C WebDriver protocol
  • Node js base classes and libraries for easily writing new drivers

Closing Remarks

Lastly, we were treated to a performance featuring Jonathan Lipps, Appium and Selenium. I believe four or five instruments were being played by Appium, Selenium was outputting the lyrics and Jonathan was singing and playing the ukulele.

My biggest takeway from this is that Appium can be used in a variety of ways to perform a number of impressive tasks.

After Party

The after party was held at a bar a short walk from St Paul’s Cathedral. There I managed to talk to Ru Cindrea in more detail about the project I wanted to use the AltUnityTester for and whether she thought it would work. I also, managed to talk the ears off of both Charlene and Charlotte who were the speakers from the very first talk of the day.

Overall

I had a great day, met loads of wonderful people (including attendees and speakers) and I hope that next year, I’ll have begun using Appium for something that I do so I can share my own experiences with the community.

A Beginner’s Guide to Testing Blockchain Applications

Last year, the hype of Cryptocurrencies and the words Blockchain were everywhere. Friends and family members where all jumping in and investing even when they hadn’t shown signs of being interested in the stock market previously. I’ve been following the ups and downs of certain stocks for a couple years now but even I was intrigued.

More than the need to invest, I was interested in how the technology that these currencies were built upon were going to affect me as a QA Test Professional. After all, someone’s got to test the software behind it all. So I decided to delve into the technology behind cryptocurrencies, Blockchain and look into what skills I’d need to test these types of applications.

Here’s my post for Simple Programmer, A Beginner’s Guide to Testing Blockchain Applications.

Building a Test Pyramid from the Bottom Up

I was brought into my current role at Immerse.io to uphold a high level of quality for the company’s awesome products. But where to start?

After I put together my test strategy I needed to know how much test coverage was currently in place.

Plenty of manual testing was taking place but it needed refining as not everything needed to be tested manually. Also, there were no test cases for the new system documented or being run so there was no way to know how much had been tested, what test was last run let alone what results those tests gained.

So with no test cases to look at, I turned my attention to the developers and their unit tests. The good news is that they had unit tests, the bad news is that they didn’t know how much. There were no code coverage tools integrated into their builds so they couldn’t tell.

So I first turned my attention to increasing unit tests in the projects and adding code coverage tools. Once we had the code coverage levels, we could work to increase the code coverage of the project codebases. If our code coverage level was high, it would give us more confidence about the quality of the system at a low level. But how many test cases should we create?

With this question in mind, I started thinking how I could use the Test Pyramid concept and apply it across our products.

What is the Test Pyramid?

The Test Pyramid is a concept that is used to determine what type of tests and how many of each type should be used at different levels within your product’s development. There are usually three different levels to the pyramid (although some depictions may contain between three to five). The image below is referenced from Martin Fowler’s blog post regarding the Test Pyramid.

As you go up in the levels there should be less tests. Also, as you progress up the pyramid, the tests become more complex because they involve connecting to more than one component or system. Therefore tests will take longer to run as you progress higher.

The Different Levels

The bottom level contains the majority of your tests. Unit tests are used for this level as run fast, have a small focus, are easy to add to and require little maintenance. Overall, they provide fast feedback on changes to the system at a low level.

The middle level contains your integration tests and the top level is for UI tests. The tests in the middle and top levels tend to be more susceptible to breaking because they connect with a number of components and systems.

UI tests are particularly brittle because they rely on web page elements which can be changed easily. Because the automation code is so tightly coupled to the page elements, if one is updated without the other, the tests will break. And, as these two codebases are usually maintained by different teams, sometimes the teams won’t remember to update one another. This could lead to one codebase being updated without the other one. These tests usually require more maintenance than unit and integration tests.

Fix issues as early as possible

The Test Pyramid supports the idea that a lot of thorough testing at the low levels and early phases of development helps to prevent bugs reaching the production environment.

Catching issues within your product during the later stages when the project is completed and ready for consumers is costly and can be more time consuming to fix. Attempting to apprehend issues, before they become defects i.e. production bugs, during the early phases of development is preferred because:

  • It involves less people to fix so can be presumed to be less time consuming
  • There is no impact to the customers so it’s less costly to the business

In your project, try and do the following when focusing on building your base level:

  • You should try to do the majority of your testing during the earlier phases of development with tests that are the cheapest to run.
  • It’s important to make sure that the amount of unit tests in your project is large enough to ensure that issues are caught and fixed before shipping.
  • Make sure you monitor the level of code coverage you have in your project to make sure you have the right amount to reach your target level of quality that will provide you with confidence in your product.

Follow the Test Pyramid and see what results you get.

Integrating Code Coverage

In order to follow the Test Pyramid concept, we first needed to build up the amount of tests in the base level.

Now that the tests were being added to, we needed them to be integrated within the CI tools we were using. So for one team, I set about getting these running within TeamCity. Using the Unity command-line test runner I managed to get this working when we were using Unity 5.4. Unfortunately, we found that this set up broke when we upgraded to Unity 5.6. Luckily, this has now be rectified in version of Unity 2017.2 and we have unit tests running in TeamCity on every build once again.

Unfortunately, there’s no way to measure code coverage on Unity projects so we’re just going have to be content with increasing the number of tests and making sure that these tests are meaningful. I’ll continue to monitor this though.

I next looked at getting a code coverage tool installed for the other team. Because of the tech stack here and how simple it was to setup on a simple project, I chose to use Istanbul. This has now been set up into a CI tool that runs on every push so that all code is checked and a code coverage report is produced. This gives us an idea of where we need to focus our efforts to increase the amount of unit tests.

Our Next Steps

As the production of unit tests are continuing and the developers are actively doing this themselves, I turn my attention to the next level of the Test Pyramid, the Integration tests.

This post was imported into WordPress in one click using Wordable.

Test Expo 2017

Last Tuesday I attended TestExpo 2017.

Since I switched back into testing, I have tried to read more about the changes in this field so that I’m more informed and in a better position to make decisions about the direction we take for QA within my day job and my personal projects.

Why is going to conferences and events good in general?

As I mentioned in my previous post, Ways to keep up your development skills as a Test Engineer, going to events like conferences or  meet ups are great for improving your technical knowledge. But, they are also great environments to flex your social muscles and converse with your peers.

Learning to approach and make conversation with complete strangers is a soft skill that everyone should look to be improving. But more than that, it gets you out of your comfort zone of interacting with the same circle of people that you deal with everyday.

Putting yourself in uncomfortable situations makes you grow by building skills you wouldn’t normally use.

Being in a place where the majority of people are dedicated to improving the quality processes and products was definitely an unusual but brilliant feeling. As I tester, particularly in agile teams, you’re outnumbered by “sole” developers (those whose main role is development). This may lead to situations where you have to champion your opinions in order to get things changed for the better. So being in an environment so different to my day to day life instantly lifted some of my nerves.

Event Vendors

At these types of events there are always opportunities for sponsored partners or vendors promoting their products.

My advice for dealing with vendors is to find out exactly what they do and only give your contact details to those who have products that you know may be useful in the future to your goals. Otherwise you could open yourself up to a lot of LinkedIn requests. By all means take as much information away, but be clear that you’ll be assessing what they have and whether it’s inline with what you want to achieve. You’ll contact them, not the other way around. It sounds a bit harsh, but in all fairness, you don’t want to waste anyone’s time, yours or theirs if their product isn’t what you’re looking for.

The vendors at this event were very honest and helpful and I got some great information in the form of the World Quality Report 2017  from Sogeti.

TestExpo talks

The day was arranged into series of talks and a round table (group discussion) session.

There were three specialty tracks being covered during the day at the event: Testing, Agile and DevOps. After the keynotes were finished, you could decide to pick and choose between talks from other tracks which I found was great as your interests may not solely be about testing.

The programme list for the day can be found on their website.

I chose to attend the talks within the Testing track. In total I attended all but one of the day’s talks (I did manage to get hold of slides from the talk that I missed so I wasn’t too disappointed).

Best talks

My favourite talks of the day were:

  • Keynote: Becoming a Unicorn
  • The core competencies of a good tester

Both of these talks made me think the most and gave me a list of actionable tasks that I believe will make me a better test engineer.

Top takeaways

  • Make UI automation tests cover key user journeys and smoke tests  and ensure a good ROI
  • The values and benefits gained from good QA should be:
    • Intelligable
    • Trackable
    • Testable
  • You should aim to deliver quantifiable results that support the business values and it’s qualities.
  • Build dashboards to share throughout the company’s teams to share quantifiable results
  • The soft skills of QA engineer are just as important as their technical and analytical skills.

Overall

There was lots of actionable information for me to think of ways to improve the testing practices that I’m currently implementing. The content was a nice mix of beginner/refresher and new/intriguing tech. The attendees were very approachable and friendly and the venue, although a bit far out (near Heathrow!), was a lovely building.

I’d definitely recommend anyone with an interest in testing going next year!

How Important Is CI and CD For An Appreneur?

I’m beginning to set up practices and procedures to help me in the long term along my journey to becoming a professional app developer.

Recently, I have been considering whether continuous integration and continuous deployment practices would be useful to set up, even at my early stage.

While I have been actively using both of these practices in my day job for the past two years, I decided that a detailed analysis would give me a better idea of how and why I should use them.

After, much thought, I think that while continuous deployment maybe too much for me to set up, continuous integration is something that would make my code more robust and improve the quality of my releases.

So in the future, I will be writing more unit tests to make the step towards CI less of a hurdle.

To read my findings, please read my latest post on Simple Programmer, How Important Is CI and CD For An Appreneur?

Setting up Istanbul on a Node project for Mac and Windows

When I took on this new role, one of my tasks was to ensure that we deliver high quality products.  In order to get an estimate of where we were currently at, I decided to look at implementing code coverage tools into the build processes so that we can gauge the level of quality we have on each product after each  successful build.

After watching the Testing JavaScript for Node.js with Mocha Pluralsight course (which I recommend for any .Net C# newbie to Mocha), I felt like I gained a good understanding of unit testing within node applications. And as an added bonus, the course even bolted on a short demo of a tool that I had been meaning to investigate. This was Istanbul.

Code Coverage with Istanbul

Istanbul is a Javascript code coverage tool that outputs the amount of code covered by unit tests in your project. It is an open source tool which is available on GitHub.

Setting Up

Whilst watching the video, I installed Istanbul into my small node project that I had been using throughout the course using npm install -g istanbul. This installed Istanbul globally to my Mac.

Next, I entered the command:

istanbul cover node_modules/.bin/_mocha -- tests/**/* (on Mac)

This is the command when trying to execute on a Windows machine:

istanbul cover node_modules/mocha/bin/_mocha -- tests/**/* (on Windows)

The Reports

After doing this, Mocha should run your tests. Appended onto the end, you’ll see a short output of the level of code coverage in the command line window that has been helpfully coloured in green or red (if other colours exist I haven’t seen them yet).

You will also now have a new directory within your project named “coverage”. In this directory, you’ll find a coverage report directory that contains a detailed HTML version of your application’s code coverage.

And that’s it!

I was very surprised how easy this was to set up and get running. The next step is to get this running on Team City! So that we can read the code coverage levels after every build and hopefully enforce a minimum level of code coverage so that whenever new features are written, if the amount of unit tests covering those new lines of code don’t increase, then we can fail the build to encourage developers to write more tests and increase the quality of their code.
<!–
Setting up for TC

  1. add to the artifacts path under general  settings the path where the html reports are output.

–>

Ways to keep up your development skills as a Test Engineer

Earlier this year I made the decision to switch back to being a QA Engineer. Due to the nature of the tech that I was now being exposed to, I wasn’t able to flex my coding muscles everyday like my previous role. I started to think that my programming skills would slowly dwindle if I didn’t do something about it, particularly the C# and .NET skills I’d spent the last two and a half years developing.

So, I endeavored to take up activities that would encourage, keep active and stretch my development skills. I have tried and keep them aligned somewhat with my new role so that I continue to improve in the field of testing as well.

If you find yourself in a similar position, here’s how you can do the same.

Before You Begin

Make sure you know what skills you’re going to be building. Have a list ready to work on or a certain project that you’re going to create so that at the end of your learning you have produced a tangible result. I use a Trello board to manage the tasks on my projects, but good old fashioned lists work just as well. Just make sure that they work for you.

Identify Your Free Time

Everyone has some time where they’re free. That morning commute where you’re sitting for 30 minutes, that walk to the bus stop that takes 15 minutes or even your lunch hour. See what I’m getting at? You just need to identify where your free time slots are, then find an appropriate action to do within that time.

Take your weekly calendar and block of these times. Seeing it highlighted in chunks can really open your eyes. Then figure out what you want to do to further your learning and what action would suit that time slot best.

Got a topic but don’t know how to progress? Having a varied selection of learning resources across different formats will mean that you can you easily slip in a bit of learning during any type of free time you have.

What You Can Do

Here’s some tasks that I recommend you try.

1. Read other developer’s code

Reading others developer’s code, especially those that are more experienced than you, can help you see how to write cleaner code.

The best thing you can do when reading others code is to try and understand why they have used the methods and patterns that they have. If after reading the code you can’t figure out the reason, why not ask them? Discussing a developer’s thought process when tackling a problem is a great way to gain insight into how you should approach a technical challenge.

Learning by yourself may take a long time. Talking with someone more experienced that have overcome the same issue could save you hours, months or even years or trial and error. So take advantage!

2. Get your work code reviewed

The feedback you get from someone external to the project (and especially those more experienced) can yield some valuable tips. You could learn how to improve your code to make it more efficient, readable, testable and durable over time.

3. Watch Pluralsight videos

Pluralsight is a online library of technical videos. I’ll be amazed if you can’t find a video here on any technical subject that you can Google.

The vast amount of videos on Pluralsight are being continually added to by professionals in their fields. Pluralsight also vets any new submissions from existing and new authors to ensure they keep the quality of their videos high.

I enjoy using Pluralsight because sometimes watching videos is easier to digest and concentrate on than reading a book cover to cover. And, when you read a technical book, you may not need every part of that book to understand the topic. Pluralsight videos are broken down into digestible chunks so you can consume short videos in small areas of your chosen topic quickly and easily.

Updating videos is also a lot easier than updating books, so you’re more likely to get up-to-date content in your topic on this platform. They also offer a download service so you can take your courses on the go and watch offline on any smartphone or tablet device.

Ok, so Pluralsight isn’t free no. But they do offer a ten day free trial to see whether you’d like it. And they have different subscription methods to ensure that you always have an option.

Why not take the free trial and see how you do. Pick a topic and see how much you can learn during your free trial.

4. Read technical books, news sites and technical blogs

Watching technical resources is great, but sometimes the information is only available in a text only.

Reading technical books that are timeless like Clean Code by Robert Martin aren’t available on any other format currently, so you have to read the book. Choose wisely what you spend your time reading as books usually take a lot more of your time than anything else to consume.

News sites are good because they offer the latest information to keep your skills and knowledge sharp and up-to-date in small articles.

Technical blogs are good at getting the opinions of those in the industry but make sure the content you read is good quality. Anyone can write a blog nowadays. I’m not saying good articles can’t be written by those less experienced in a subject. I suggest that if you are working from the advice of someone new to the area you’re studying, work through what they suggest to verify their work.

5. Listen to coding or development podcasts

Utilising the time you spend traveling from one location to another is the most overlooked part of your day to use to learn.

During this time, providing you know where you’re going and aren’t talking to someone or doing something else at the same time, you can listen to coding and/or development podcasts to help you improve your skills. I find most of these aren’t too coding heavy but more often discuss high level concepts, technical updates, short code-based questions (that require short answers) or soft skills for software developers. Some coding/development podcasts I listen to are the Xamarin podcast, Simple Programmer and Hanselminutes.

6. Write different types of test automation e.g. Unit, integration, UI

You should understand the different types of tests that you can create for different stages of development. But, I would also recommend trying to learn how to develop these tests as well within your company’s tech stack.

Being able to apply what you have learned is more important than just saying you know how to do it.

Regardless of your job role, you may find that you have the opportunity to add some unit tests or write an integration test. Unfortunately, I’ve found that this is completely dependant on the attitude of your company and the developers in your team. You are a developer too, so if you want to contribute to these types of tests, make sure your team are aware of your interest and figure out how to get started.

At the end of the day, being well versed in different types of automation testing will make you invaluable to any team and any company.

7. Attend conferences and events

These can be free or not. The cost of the event doesn’t necessarily correlate to what you’ll learn from the event.

If you don’t know where to start, check your local meetups for events.

Early in September, I attended the ASOS QA meetup event in London where Simon Stewart spoke about the future of Selenium. It was great. I learned a lot about the history of how Selenium came to be one of the most common automation testing frameworks. I also spoke with some really nice, passionate people about their roles in the field of testing.

You can learn lots from conferences and events, not only from the scheduled talks, but from the people also attending. If you do decide to go, try and speak to at least one new person and find out about them.

People going to conferences usually have the same goals, to network and learn. The problem is that many who attend are usually shy, so why not be the first one to be brave and start a conversation.

Also, don’t limit yourself to only testing events. Make sure you go to both testing and development ones. You have skills in both fields so it makes sense that you might get something out of both types of events.

Don’t put a limit on your learning resources or experiences. You don’t grow if you’re not stretched.

8. Write a blog about testing while you learn

John Sonmez says in his 10 steps to learn anything quickly course, that the best way to solidify what you’ve learned is to teach it to others. The fastest, lowest barrier and least intimidating way to teach people is to start a blog detailing what you’re learning.

First, start by picking your blog topic and ensure you pick something niche. For example, don’t write about video games, write about the presence of females in video games between 1990 to 2000 within the role-playing (RPG) genre (if anyone had started a blog about this I would definitely subscribe!).

Next, commit to a schedule. I know it’s hard to stick to schedules because you do so much in life, but this is where identifying the free gaps in your week can help. Pick one of those gaps and dedicate it to writing articles for your blog.

Most new blogs fail within the first three months. Having a schedule will make sure you keep your blog content fresh and interesting to encourage new and returning readers to keep visiting.

A clear focus for your blog will help you to filter out any ideas for posts that may divide your decisions about what you write about. Having a clear focus also helps your audience as they’ll know if they have a problem or want to learn about the most well-known female RPG character in 1995, then your blog is what they need to be reading.

It can be hard to continually think of subjects to write about whenever your schedule dictates. Why not keep a list of your topics so you can regularly pick from it so you don’t have to think about what you’re writing about next? This is what I do. I keep a Trello board because it’s easy to access from a desktop or my mobile when I’m planning my daily tasks on a commute. And it’s very simple to use and tailor to my workflows. It’s also free, so there’s no reason why you can’t give it a try.

9. Write your own code

Practice makes perfect. Figure out what you want to learn or what side project to be focusing on to help you progress in your goals. Then, you can start planning the classes or methods you’ll need. If you’re practicing test-driven development, you may want to start writing unit tests but if not you can start crafting a class and basic method and go from there. Being able to refactor your code is a skill that writing code a lot can build. So the faster you begin the faster your skills grow.

Don’t have a goal? Get one. Do anything even if it’s small so you can practice writing code. The hardest part is starting.

Start With Just One

Try to build a habit of doing this so it’s second nature and you feel like you’ve missed something if you don’t complete your task. Once you’re happy you’ve successfully worked it into your routine, start adding another into your schedule.

Even if you’re only able to enforce and keep up one new habit you’ll soon notice results. I can’t guarantee perfect results fast but I can tell you that when you start doing these things regularly, it will make to think differently about how you approach a task so that you apply what you have learned.

For more ways of keeping up your coding skills, John Sonnez has written a similar post that you may want to read.

And that’s the secret to keeping up your skills. To keep learning a little at a time and applying what you learn in practical ways.

This post was imported into WordPress in one click using Wordable.