<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Charlene Bastians on Medium]]></title>
        <description><![CDATA[Stories by Charlene Bastians on Medium]]></description>
        <link>https://medium.com/@charlenebastians?source=rss-d2d6b0becf4b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*yKSvyTzHnL4M0yInejleUw.jpeg</url>
            <title>Stories by Charlene Bastians on Medium</title>
            <link>https://medium.com/@charlenebastians?source=rss-d2d6b0becf4b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 21:02:04 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@charlenebastians/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[What is DevOps]]></title>
            <link>https://medium.com/@charlenebastians/what-is-devops-7d066012135d?source=rss-d2d6b0becf4b------2</link>
            <guid isPermaLink="false">https://medium.com/p/7d066012135d</guid>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Charlene Bastians]]></dc:creator>
            <pubDate>Thu, 14 Feb 2019 15:31:45 GMT</pubDate>
            <atom:updated>2019-03-04T12:11:44.530Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This article is intended for those have little or no prior knowledge of DevOps</em></p><p>Ask this question to many who work in tech and you’ll often get back a list of tools such as Jenkins, Ansible, Puppet etc. Whilst it’s not incorrect that these tools are indeed related and important to DevOps, these responses don’t fully portray DevOps for what it is.</p><p>A quick google will tell you it’s a ‘grass-root movement’ and a ‘set of principles’. But why? Why do we need Devops Principles and what are they? So the term DevOps is an amalgamation of ‘Developer’ and ‘Operations’, and a quick answer to the question what is DevOps will often involve this response.</p><p>To understand the DevOps movement and it’s evolution, we first need to understand Waterfalling and it’s failures. Now, I could spend a long time talking about what Waterfalling is and why it doesn’t work, but for the purpose fo this blog, understand that Waterfalling looked at building software a lot like we look at building a house. Until one part was complete, the next part wasn’t started. This wasn’t a very speedy way of doing things. Lots of time was spent on planning the application before any code was actually written, then when the development part came, it came poring down in one long stream… like a waterfall. Very little time was left for testing. This led to a lot of bad software that wasn’t easy to maintain.</p><p>In comes Agile to the rescue. Agile development is all about small iterations and testing early. Fantastic, but now we have the developers focusing on speed and the operations team focusing on stability.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/741/1*LABMWGtP6KNyIefUKObTuw.jpeg" /></figure><p>What does stability hate? Change. But now we have a model that encourages developers to embrace change, and make as many small changes as necessary without thinking about Operations.</p><p>In 2008, Patrick Debois and Andrew Clay Shafer started the discussion about the conflicts between developers and system admins. In 2009, Patrick Debois organised a conference called DevOpsDays to address his (and others) growing concern about the gap Development and Operations. After the conference, the debate was taken to twitter where the hashtag was shortened to #DevOps.</p><p>Since then, the DevOps movement has sought to bridge the gap between Agile Development and Operations whilst keeping an emphasis on both speed and stability and share goals. How does it do this?</p><p>It starts with people. People, process, tools, in that order of importance. DevOps is really about the flow between people and the processes they exert. Adopting DevOps really means adopting it’s culture. So what is it’s culture? The key is collaboration. There is an emphasis on sharing of knowledge and responsibilities. You have to break down barriers and start thinking like a unit all responsible for the software development life cycle. Shared goals is a big part of this.</p><p>One of these shared goals that DevOps focuses on is a faster time to market. Time to market is the time it takes from Developer writing code to it being deployed to it’s customers/users. A faster time to market satisfies the Agile Developers need for speed.</p><p>Another goal is recognising when something has failed quickly. This satisfies both the need for stability and speed. So we want tools and a system in place which gives us immediate feedback about our software and tells us if something isn’t working as it should.</p><p>It’s all well as knowing something has failed immediately, but you also need a way of fixing that issue as quickly as possible, it’s incredibly useful to a company if they can fix this problem before the software is deployed to their users.</p><p>The CAMS model aims to address everything DevOps should be. It stands for Culture, Automation, Measurement and Sharing. Culture — As we’ve already touched upon is the breaking down of silos and an increase of communication and fluidity between engineers. Automation —The use of automation is one of the key aspects of DevOps. Not only does automation take far less time than manually checking something, but it lowers the potential for human error and requires less human resources. Measurement — So how do you know your application, tests and tools are doing what you want them to do? How do you know you are actually providing value? We have to measure everything we do in life to know if we are doing well enough. We can do this in software development with the use of monitoring and analytics. And finally Sharing — Without the sharing of ideas, code and knowledge, there is no team. If you write some code to find a solution for a problem, make it open source. This doesn’t just benefit others but someone might offer up a contribution to better improve your solution. Conferences are a great way of sharing knowledge, a lot of DevOps companies hold in-house conferences/workshops to pass on skills and information.</p><p>DevOps and Agile Software Development go hand in hand because both are fluid. Both emphasise the people and relationship between them, and both are about early feedback and fast delivery. Agile software development fits very well into the DevOps way of doing things.</p><p>DevOps keeps a lot of what we learnt works with Agile development, we still want incremental changes in code, we need a solid branching strategy for version control, we still want to test early. DevOps goes further than Agile development and addresses the silos between teams. By looking at building applications from the DevOps perspective, you combine speed with stability and increase revenue through faster time to market.</p><p>Imagine you have a team of people all responsible for every stage of the creation and deployment of the app. The Developers write the code and integrate it into a master copy after automatically checking all tests have passed. QA make the necessary checks that it has fulfilled the requirements and the code is automatically deployed to users in a timely manner. But what if there’s a problem? What if the version released has a bug or defect that no one has spotted. In DevOps, we can use automation to roll back to a working version until the issue with the new version is rectified. With good monitoring of the production environment, very few or no users may even learn of this bug’s existence.</p><p>In the old days there were a lot of silos. So Devs worked so independently from Operations that if one side made a big change (which happened often with the old waterfalling system) it implicated the other side to the point that they may not even be able to carry on with what they were working on. DevOps aim is to rectify this problem. Instead of having Devs work independently of each other, who in turn work independently from the Operations team, a DevOps team has no such titles. Everyone is a DevOps Engineer and can act as a bit of a Swiss army knife when it comes to keeping the DevOps flow moving, everyone has the same mindset and the same goal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/666/1*rXY3_XtTM6XWdZD1_IGhDA.jpeg" /><figcaption>This Cycle happens with continuous testing always happening by a QA Engineer</figcaption></figure><p>The tools and technology have also changed because of DevOps. Take Jenkins for instance, this Continuous Integration and build/release tool has been embraced by many areas of the tech community, not just those that adhere to the DevOps model. Jenkins can run your tests for you and undertake a build all without you being there. The speed and efficiency of tools like Jenkins are incredibly valuable to a company that had maybe once done these things manually. It frees us people to work on bigger problems and avoids human error.</p><p>There are certain concepts and practices that are integral to DevOps:</p><p>Build Automation — There might be things you need to do to your code to prepare it for a live environment, such as linting or compiling, Build Automation does this. The script lives in the source code so anyone who pulls the repo can also utilise the same build automation. Jenkins is a particularly useful tool for this.</p><p>Continuous Integration — Instead of having large amounts of code being added to the master repo infrequently, causing problems that can be hard to trace, it’s much better to make small frequent changes to the codebase. Every time you make a commit, a CI tool runs several tests before creating a build. The idea is to create early feedback, you want to know what’s failing, a failing test isn’t a bad thing, it’s something to learn from. Again, Jenkins really comes in handy here as it can take responsibility for running the tests before integrating code and running builds.</p><p>Continuous Deployment — Frequently deploying code to production. AWS CodeDeploy is a good tool for this.</p><p>Continuous delivery — maintaining your code so it is always in a state to be deployed, even if it isn’t deployed immediately. You may not want to for business reasons. The difference between Continuous Deployment and Continuous Delivery is with Continuous Delivery, someone manually approves the deployment to production whereas with Continuous Deployment the entire process is automated.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/721/1*XwUZ1C3jiJMDDTq7dPYz-g.jpeg" /></figure><p>Infrastructure as Code — The managing of configuration tasks that might usually be done manually (eg. managing servers, managing containers) in an automated way using code.</p><p>Configuration management — the management of infrastructure in an automated way. It minimises configuration drift, which is what happens when there a lot of small configuration differences implemented across systems over time and those differences cause performance issues. Chef, Ansible and Puppet are popular tools in this field.</p><p>Orchestration — It’s about automation. It’s about enabling processes and workflows. For example, a company might have a busy period in which it requires more servers, rather than manually set those servers up, orchestration tools will run them automatically, and know when they need shutting down again. Kubernetes is a good example of this, Kubernetes can be used to orchestrate containers with Docker for example.</p><p>Monitoring — The importance of monitoring is tied in with successful continuous deployment. If you are going to continuously deploy to your users, you want automated tools which tell you quickly if there is something wrong. This is what monitoring does. It is an integral part of DevOps. Monitoring can also give feedback in the form of data explaining <em>why</em> something failed.</p><p>Microservices — rather than having all your services and systems in one monolith, we break them up into their own processes. A bit like why we encapsulate code, we break services down into small manageable parts so if one breaks, it doesn’t break the whole application, just that small part.</p><p>Quality Assurance and Testing — Testing really is an ongoing process in DevOps. We need feedback during every stage of the software development life cycle. There are Unit tests and functional tests which test a small, singular part of the code, Integration tests which test from one microservice to another and e2e testing which can test across multiple microservices. Then there’s also Acceptance testing which tests that features meet the clients criteria and satisfy the user, and feature testing which tests a feature from start to finish. This could be an e2e test, be in the front end or back end or across both. There is a wide variety of testing which could be classified as feature testing.</p><p>As well as testing, there is also analysis. There is static analysis and dynamic analysis. Static analysis is done when there is no execution of the program. Static analysis can look for flaws in the code such as syntactical errors and let you know before you have even run your unit tests, thus finding weaknesses and errors even earlier than when you integrate code. There are many tools which do this, a linter perhaps. I’m sure anyone who’s ever used a linter before knows how annoying a false warning can be, so these tools come with a downside. Dynamic analysis evaluates the program whilst running the program in real-time. It looks for vulnerabilities from a security perspective, alerting you to entry points and other vulnerable sections in your program. QA testers will often carry out some sort of analysis as part of their duties with the aid of automated tools.</p><p>To summarise, DevOps is all about flow. It’s how people think and communicate with each other and the processes they build together that makes DevOps successful.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7d066012135d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Essential debugging advice for beginners.]]></title>
            <link>https://medium.com/@charlenebastians/essential-debugging-advice-for-beginners-c2ef7aa7dceb?source=rss-d2d6b0becf4b------2</link>
            <guid isPermaLink="false">https://medium.com/p/c2ef7aa7dceb</guid>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Charlene Bastians]]></dc:creator>
            <pubDate>Wed, 12 Sep 2018 10:49:30 GMT</pubDate>
            <atom:updated>2018-09-12T10:49:30.914Z</atom:updated>
            <content:encoded><![CDATA[<p>What are bugs? Bugs can be any number of things. It can be a typo or spelling mistake in your code, it can be the use of wrong terminology or it can even be a larger problem with your fundamental understanding of your chosen language or framework. Rarely is it the latter. Most bugs are annoyingly something so small, your eyes and brain simply don’t see it when reading through your code. So how do you find a needle in a haystack?</p><p>If you’ve ever been annoyed enough by an app you’ve been trying to use before, only to find a nasty bug which doesn’t let you get what you want out of it, you may have submitted a bug report. The first thing you are asked is to describe the steps you took to reproduce this bug. This is vital information for any developer and something you should have clear in your head when debugging your own code. Write these steps down. If you are working as part of a team, having it written down might encourage a team member to hep you out, at the very least, you wont have to repeat yourself all the time when explaining to others.</p><p>How do you define what the problem actually is? Ask yourself what your code should be doing and then clarify what you observe it to be doing. It is this discrepancy you will be aiming to solve.</p><p>Error messages are your friend. Learning how to read a stack trace is an essential skill for all developers. Before playing with your code, understand what the error message is trying to tell you. At first, this can be quite daunting and it may seem like jargon to you, but after a while, you start to learn what error messages <em>actually </em>mean. They wont tell you that you forgot a closing bracket and it wont tell you if you mispelled a word, you maybe simply be told it’s a syntax error or a variable has come back undefined. After some practice, you will learn what these errors are actually telling you.</p><p>If you still can’t decipher it’s cryptic nature, there’s always good old google. Stack overflow is filled with similar problems arising in identical error messages… though this doesn’t mean the fix is a one-size-fits-all countermeasure. Have a good read of the original poster’s issue and decide if it’s relevant to your problem.</p><p>If you want a good understanding of what your framework or library can do, Stack Overflow has it’s limitations. Reading the official documentation bit by bit is an excellent way to expose yourself to a trustworthy resource. Who better to describe the tools you’re using than the people who made them.</p><p>Read your code well. There is a well known technique called ‘Rubber Ducking’ in which you explain your code line by line to an inanimate object, such as a rubber duck.</p><p>In different languages there are different ways to check the logs. In Javascript there is of course console.log which takes an argument of whatever you want to inspect. This can be particularly useful when trying to gain visibility to see if the specific units are doing what they are supposed to be doing. It can be a good experimental way to see what your data is doing. But it has it’s limitations. You have to know what to console.log to begin with, which for a beginner, can be tricky. Also, you don’t need to log an object or function in your code, maybe you want to understand how asynchronous javascript works, by logging different numbers in different sections of your code, you can see which parts are being executed and in what order.</p><p>Isolate the problem. Is it your code, is it the database? It is important to know where your bug actually lives.</p><p>If all these fail and you need to ask for help, do your colleague/fellow student/friend a favour and have a clearn explanation written down, including everything you’ve tried and what the logs said. This will save you a lot of time and might even nudge something in your brain whilst doing this.</p><p>And finally, keep calm! It’s easy to get frustrated at bugs that seem to be taking a lot of your time, but this is the profession you have chosen and keeping your emotions in place are just as important as all the techniques I’ve mentioned. You are never going to escape bugs, so may as well get used to them.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c2ef7aa7dceb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[HTTP actions for a Restful API]]></title>
            <link>https://medium.com/@charlenebastians/http-actions-for-a-restful-api-c78fb9a15efd?source=rss-d2d6b0becf4b------2</link>
            <guid isPermaLink="false">https://medium.com/p/c78fb9a15efd</guid>
            <category><![CDATA[api]]></category>
            <dc:creator><![CDATA[Charlene Bastians]]></dc:creator>
            <pubDate>Fri, 31 Aug 2018 11:27:35 GMT</pubDate>
            <atom:updated>2018-08-31T11:27:35.990Z</atom:updated>
            <content:encoded><![CDATA[<p>HTTP actions for a Restful API</p><p>Here is a breakdown of all the HTTP verbs used when building a Restful API:</p><p>Get: Get requests are used to retrieve information. The resource is not modified in any way. Multiple get requests to the same resource would result in the same resource being sent back identically each time.</p><p>Post: Sending a request to the server with new data to be saved. It creates an entirely new resource.</p><p>Put: Similar to a post request but does not replace the entire resource, it instead updates an existing one. If the resource does not exist, the API can decide to create a new one.</p><p>Delete: Delete requests delete the entire resource. Multiple attempts to delete the same resource will not change the outcome.</p><p>Patch: Similar to a Put request but it only updates a partial resource and does not create a new one.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c78fb9a15efd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to problem solve with Divide and Conquer]]></title>
            <link>https://medium.com/@charlenebastians/how-to-problem-solve-with-divide-and-conquer-f9a3371ad373?source=rss-d2d6b0becf4b------2</link>
            <guid isPermaLink="false">https://medium.com/p/f9a3371ad373</guid>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Charlene Bastians]]></dc:creator>
            <pubDate>Fri, 31 Aug 2018 09:38:16 GMT</pubDate>
            <atom:updated>2018-08-31T13:40:38.951Z</atom:updated>
            <content:encoded><![CDATA[<p>How to problem solve with Divide and Conquer</p><p>A useful method to get over a hurdle in software development is to break it down into smaller manageable parts and tackle those one by one. Then once all smaller parts are solved, put them all together to complete the puzzle.</p><p>Agile development is a good example of divide and conquer. The application is broken down into smaller parts, and developers start by doing the smallest thing possible to implement a feature or make a test pass.</p><p>It is also a good strategy when it comes to debugging. It’s often useful to strip your code down into smaller functions to sniff out what area is really the culprit. This is where unit tests can come in particularly handy. In a way, they already implement the divide and conquer technique.</p><p>There are many Divide and Conquer algorithms that have been devised. One of which is Quicksort. A basic level explanation of this algorithm is that Quicksort selects an element as a pivot point and sorts everything relative to that pivot point. It utilises recursion to select a pivot point within the already sorted points and keeps on sorting those elements until the array is fully sorted.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/703/1*FDWQ9HQyjMg8m5BTeK_TWg.png" /><figcaption>Example of a Quicksort algorithm.</figcaption></figure><p>So remember, when building something large scale, think small!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f9a3371ad373" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Test Early, Test Often.]]></title>
            <link>https://medium.com/@charlenebastians/test-early-test-often-d669d7252d30?source=rss-d2d6b0becf4b------2</link>
            <guid isPermaLink="false">https://medium.com/p/d669d7252d30</guid>
            <category><![CDATA[testing]]></category>
            <dc:creator><![CDATA[Charlene Bastians]]></dc:creator>
            <pubDate>Tue, 28 Aug 2018 16:14:18 GMT</pubDate>
            <atom:updated>2018-08-28T16:14:18.441Z</atom:updated>
            <content:encoded><![CDATA[<p>Test Early, Test Often.</p><p>Testing! When learning to code, testing isn’t always the most exciting thing to learn at first. But it is vital if you are going to release your applications in small iterations with continuous integration.</p><p>Testing can improve security and save valuable time when refactoring. Imagine you had to manually check a piece of code that gets refactored several times. A much easier way to do that? Just simply run the tests.</p><p>Tests also act as a specification for a certain feature. Want to know what an application or a certain feature does? Look at the tests!</p><p>By testing early, you can sniff out bugs at a low level. You don’t want to end up half way through the building of your application, just to find out there are loads of bugs. Where do you start? You fix one and another one pops up and you start to question yourself whether or not you actually fixed the original one or just made it worse! By testing early, it lets you tackle the bugs one by one as they come up.</p><p>They’re inexpensive to write and could potentially save you a lot of time and money. The only way of making sure your code is thoroughly tested is by writing as many tests as you find useful. Good code coverage with tests is an excellent way to prevent those awful bugs from rearing their heads when you are about to release your app.</p><p>So always write tests first! And test frequently.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d669d7252d30" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[You aren’t gonna need it!]]></title>
            <link>https://medium.com/@charlenebastians/you-arent-gonna-need-it-f61a5928fa80?source=rss-d2d6b0becf4b------2</link>
            <guid isPermaLink="false">https://medium.com/p/f61a5928fa80</guid>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Charlene Bastians]]></dc:creator>
            <pubDate>Tue, 28 Aug 2018 15:52:50 GMT</pubDate>
            <atom:updated>2018-08-28T15:52:50.941Z</atom:updated>
            <content:encoded><![CDATA[<p>You aren’t gonna need it!</p><p>YAGNI, or You Aren’t Gonna Need It is a principle behind ‘do the smallest thing possible’ that we consider when writing code.</p><p>It’s very tempting to write our code preempting what features we are going to add in the future, but if we work in an agile environment, the emphasis is on small iterations. The temptation might be there to plan ahead as a means of saving time or money, but we’ve learnt this is not what happens.</p><p>Before Agile started to become popular, Waterfalling was the approach commonly used by professionals (and is still used today). There was a substantial amount of planning and the applications were not built in small iterations, they wrote the code all at once and tested afterwards. This would have meant that code preempting future features got written too. Many companies came to the realisation that this did not save any time, if anything, this made building applications longer and therefore, more expensive.</p><p>What if a client comes back to you and changes their mind on a feature, or they want to make changes, you’ve already written code to implement it, now you have to delete it all but don’t have a working version where it doesn’t exist.</p><p>What if you get stuck on some complex features and are racing against a deadline to go live with your app, you can’t go back to a working version and release that because you don’t have one.</p><p>Also, think about readability. You have a some code that is to be used on a feature coming up in the future, do others immediately know that when looking at the code?</p><p>When implementing features and making tests pass, doing the smallest thing possible is the best advice given in the Agile world.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f61a5928fa80" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Keep it simple stupid!]]></title>
            <link>https://medium.com/@charlenebastians/keep-it-simple-stupid-2125a2a7c6a4?source=rss-d2d6b0becf4b------2</link>
            <guid isPermaLink="false">https://medium.com/p/2125a2a7c6a4</guid>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Charlene Bastians]]></dc:creator>
            <pubDate>Tue, 28 Aug 2018 15:09:14 GMT</pubDate>
            <atom:updated>2018-08-28T15:09:14.909Z</atom:updated>
            <content:encoded><![CDATA[<p>Keep it simple stupid!</p><p>A common acronym in Software Development is KISS, it stands for Keep it simple stupid. It’s a philosophy which can be applied to many areas in life, but it is particularly useful when writing code as part of a team, or even just writing code for yourself.</p><p>Why do we keep things simple? Well, imagine we didn’t. Imagine code that is so hard to decipher that when we show it to a colleague, they haven’t got a clue what it does or how it works.</p><p>Or imagine code that you leave for a few weeks, then come back to. If it takes you a long time to decipher your own code, there’s probably a better way to write code.</p><p>When writing code, it is not the time to show off with all the advanced techniques you’ve picked up. The smartest code is the simplest. Writing complex code is also slower, and no one wants to take an eternity on writing something that could be done in half the time, I’m sure it doesn’t bode well with clients who might be paying for your time.</p><p>And what if this code is going to be around for a long time, some legacy code date back to decades earlier. Every time someone new comes on board, imagine the hassle in having to explain extremely complex code.</p><p>When designing something, anything, simplicity is definitely the key.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2125a2a7c6a4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is DRY and why do we use it?]]></title>
            <link>https://medium.com/@charlenebastians/what-is-dry-and-why-do-we-use-it-9f0e0c4f63c7?source=rss-d2d6b0becf4b------2</link>
            <guid isPermaLink="false">https://medium.com/p/9f0e0c4f63c7</guid>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Charlene Bastians]]></dc:creator>
            <pubDate>Tue, 28 Aug 2018 14:34:39 GMT</pubDate>
            <atom:updated>2018-08-28T14:46:09.959Z</atom:updated>
            <content:encoded><![CDATA[<p>What is DRY and why do we use it?</p><p>DRY stands for Don’t Repeat Yourself. What this means is if you have code which duplicates itself, it’s a sign of bad code that can be refactored.</p><p>So how do we do this? Polymorphism is a good way of doing that. We write a bit of code that can be used over and over again.</p><p>I have recently been working on the Roman Numerals Kata where I was introduced to this:</p><pre>const numerals = [<br>{value: 10, numeral: &#39;X&#39;},<br>{value: 9, numeral: &#39;IX&#39;},<br>{value: 5, numeral: &#39;V&#39;},<br>{value: 4, numeral: &#39;IV&#39;},<br>{value: 1, numeral: &#39;I&#39;}<br>]</pre><pre>const kata = {<br>translate: (num) =&gt; {<br>let result = &quot;&quot;<br>numerals.forEach(function(item) {<br>  while (num &gt;= item.value) {<br>    result += item.numeral;<br>    num -= item.value;<br>  }<br>})<br>  return result<br>  }<br>}</pre><p>This works by DRYing up code by not writing out separate while loops for each value. But what about the repetition in ‘numerals’ ? We could further DRY this up by using a function that takes in two parameters, then feed it our value and numeral. Like so:</p><pre>const numeralChanger = (value, numeral) =&gt; {<br>  return {value: value, numeral: numeral};<br>}</pre><pre>const numerals = [<br>numeralChanger(10, &#39;X&#39;),<br>numeralChanger(9, &#39;IX&#39;),<br>numeralChanger(5, &#39;V&#39;),<br>numeralChanger(4, &#39;IV&#39;),<br>numeralChanger(1, &#39;I&#39;),<br>]</pre><pre>const kata = {<br>translate: (num) =&gt; {<br>let result = &quot;&quot;<br>numerals.forEach(function(item) {<br>  while (num &gt;= item.value) {<br>    result += item.numeral;<br>    num -= item.value;<br>  }<br>})<br>  return result<br>  }<br>}</pre><p>This makes it much easier if we want to add more numerals and test for larger numbers. By exposing the duplication at first, we can see where we need to DRY up code.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9f0e0c4f63c7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Learning how the internet works.]]></title>
            <link>https://medium.com/@charlenebastians/learning-how-the-internet-works-e8287df7213a?source=rss-d2d6b0becf4b------2</link>
            <guid isPermaLink="false">https://medium.com/p/e8287df7213a</guid>
            <dc:creator><![CDATA[Charlene Bastians]]></dc:creator>
            <pubDate>Fri, 17 Aug 2018 15:46:44 GMT</pubDate>
            <atom:updated>2018-08-17T16:01:29.240Z</atom:updated>
            <content:encoded><![CDATA[<p>As the newest Junior Developer at Transform UK, I have been tasked with getting to grips with some of the basics. How does the Internet actually work?</p><p>So what is the internet? It’s a network of global exchanges, using Transmission Control Protocol/Internet Protocol (TCP/IP) — which is a set of rules about how two or more computers communicate — to transmit data via various types of media.</p><p>In the client/server model, the client is the side that makes a request — usually via Hyper Text Transfer Protocol (HTTP) — to the server. The client also displays the response. So for instance, when you search on Google, a request is made to Google’s IP address, with a header containing information about the sender like the IP address and information about the browser among other things.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/337/1*UZIkQDHIH2hLeVVD9QsehQ.gif" /><figcaption>Client/Server model</figcaption></figure><p>The data is split up into smaller structures called Packets. These Packet’s structure depends on the type of packet but usually contain a header and a payload. The Packet travels through the Local Area Network (LAN), this network connects all devices that have internet access. A router switch routes the packets in the right direction.</p><p>As Packets arrive at their destination, they are picked up by the network interface, they may then be picked up by proxies and firewalls before entering through different ports. The Packets are reassembled to the original data chunk once they reach their destination.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/803/1*dUJQy5Q6ycF3eXQ7M3bgyg.png" /><figcaption>Data Packets</figcaption></figure><p>In this example this would be Google’s server. It makes the request based on the URL and search parameters and a response containing a list of all pages including the search parameters is returned via Packets once again. Once the response reaches the client side, the appropriate web page is displayed to the user.</p><p>Every time you search on Google, this is the process that happens instantaneously.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e8287df7213a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Acebook — Day 2]]></title>
            <link>https://medium.com/splendaberg/acebook-day-2-bf99c0fb27ea?source=rss-d2d6b0becf4b------2</link>
            <guid isPermaLink="false">https://medium.com/p/bf99c0fb27ea</guid>
            <category><![CDATA[ruby-on-rails]]></category>
            <category><![CDATA[makersacademy]]></category>
            <category><![CDATA[remote-working]]></category>
            <category><![CDATA[social-media]]></category>
            <dc:creator><![CDATA[Charlene Bastians]]></dc:creator>
            <pubDate>Tue, 10 Apr 2018 19:25:20 GMT</pubDate>
            <atom:updated>2018-04-12T14:51:57.822Z</atom:updated>
            <content:encoded><![CDATA[<p>You don’t need to tell a wanna-be software developer the many ways in which technology has come to the rescue when we are faced with a problem. Take for instance, the problem of being sick when you’re tasked with a group project. Unfortunately for me, this was my situation during a group project at Makers Academy. In an age where pretty much everything can be done online, I was not ready to admit total defeat and not contribute to the team, so the decision was made to work remotely. Something many software developers do full-time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/1*_IXorDimJ5yNBDVIjqAToA.gif" /></figure><p>With the projecthaving been split up on Trello (a group project site) into smaller tasks, this seemed like it was going to be a doddle. At least that’s what I thought. There are many different technologies to help remote workers, Slack is a popular messenger app for software developers as it includes formatting features similar to Markdown and lets you send code snippets to colleagues in a highly readable format. Then there are remote pairing websites where you can send someone a remote view of your computer screen so you can work through your code in realtime.</p><p>Having started the day confident of the task I was undertaking, it wasn’t that long before I ran into issues. This week is all about becoming familiar with Ruby on Rails, a Ruby based framework that I’ve never used before. My duty was to build on the existing code and implement a comments feature for our Social Media site Acebook (any similarities to Facebook is totally coincidental… Promise!). I found some good online tutorials which explained things really well, however, my code wasn’t doing what it was supposed to do. Now what?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/261/1*SCDfs4vhb0lku7vJLXwiaQ.gif" /></figure><p>I tried to get in touch with the rest of the guys to see if they could help but when you’re on the other side of London, you can’t simply just cry out for help. The guys were busy with their own tasks and trying to explain the situation on Slack isn’t all that effective, especially when it’s not crystal clear what exactly the situation is. After contemplating the various different remote paring options (all of which come with their drawbacks, mainly lack of speed), I decided to suck it up and come in.</p><p>Now don’t get me wrong, I feel like working remotely is a good solution to some of the issues this industry faces. Whether it’s keeping overheads at a minimum or, trying to embrace a culture of flexibility to best suit the various personal situations of your employees, working remotely can be an effective solution to a problem. However, when you’re a noob like me, and you feed off the support and technical assistance from your fellow cohort members, maybe remote working isn’t always the best idea.</p><p>Armed with a bottle of hand sanitiser and a solemn promise not to lick anyone, I arrived at Makers HQ about 2:30. The guys in my team were also trying to debug a similar error and one of the coaches talked us through some of the peculiarities of Rails, we understood that our errors came from the smallest of demons… The letter S.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/263/1*0nHffjIuBhQO7y0V_lA17Q.gif" /></figure><p>Creating databases in Rails is simple enough stuff, as long as you pay attention to the distinction between the singular and plural names which Rails automatically hands out. So your table might be called “Comments” but Rails will automatically label a row a “Comment”. Sounds pretty obvious but if you have any errors in your schema, it’s not always the most obvious mistake to spot.</p><p>Once we figured out that Rails was unforgiving in confusing this distinction, we made our way forward and as the whole group gathered, made some excellent progress with our Acebook app.</p><p>We had a retrospective at the end of the day, during which we raised some questions for us to think about. We talked about what went well and what didn’t. This culture of ‘retros’, ‘stand-ups’ and general emotional ‘check ins’ is one that Makers has instilled in us. They take a very holistic approach here, one in which it is not outside the realm of possibilities to indulge in group hugs or daily meditation. As quirky as that may sound, it has been an eye opening experience which has made me realise that emotional intelligence is every bit as important as technical understanding. A happy coder is a proficient coder.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*3f8DJmasj9Gn8lRH2Bo-jw.gif" /></figure><p>All in all, it was an excellent day of programming, with a great group of guys (Julian, Alfie and Tom). Day 2 was painless enough, let’s just hope the rest of the project is too.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bf99c0fb27ea" width="1" height="1" alt=""><hr><p><a href="https://medium.com/splendaberg/acebook-day-2-bf99c0fb27ea">Acebook — Day 2</a> was originally published in <a href="https://medium.com/splendaberg">Splendaberg</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>