<?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 Kamil Wysocki on Medium]]></title>
        <description><![CDATA[Stories by Kamil Wysocki on Medium]]></description>
        <link>https://medium.com/@kamilwysocki?source=rss-490524ef0a12------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*bnJK_JpafyNOhs-rny1YiQ.jpeg</url>
            <title>Stories by Kamil Wysocki on Medium</title>
            <link>https://medium.com/@kamilwysocki?source=rss-490524ef0a12------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 01:36:51 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kamilwysocki/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[Owning it 101.]]></title>
            <link>https://medium.com/uxpin-engineering/owning-it-101-a73febe0e5a2?source=rss-490524ef0a12------2</link>
            <guid isPermaLink="false">https://medium.com/p/a73febe0e5a2</guid>
            <category><![CDATA[product-development]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[scrum]]></category>
            <dc:creator><![CDATA[Kamil Wysocki]]></dc:creator>
            <pubDate>Thu, 26 Jan 2017 14:23:31 GMT</pubDate>
            <atom:updated>2017-01-26T14:23:31.219Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*f-udY0JvHpv7IrTccGiOZw.jpeg" /><figcaption>Illustration: <a href="https://dribbble.com/adamzielonko">Adam Zielonko</a> / UXPin</figcaption></figure><p>Imagine a person who has been trying desperately to have a baby for a few years. What would you think about them if they’ve left the little one right after it’s been born? If you’re not a psychopath, you’d probably find him lacking responsibility, devotion and logic.</p><p><strong>Why git commit, git push and forget then?</strong></p><h3>What an average developer does…</h3><p>One of the things that motivate us, developers, are challenges. Difficult tasks which require exceptional problem solving skills. Or a new technology which is interesting and mastering it becomes a point of focus.</p><p>There are also certain situations that annoy us. A critical bug which distracts us from our work and has to be solved <em>as soon as ASAP</em>. A nasty task which hopefully, we will never be assigned to.</p><p>Whether it’s a feature that excites us or a day long bugfix which makes us frustrated, we sometimes tend to forget that our responsibility does not end after pushing the code to the repository.</p><h3>…and what a brilliant one does</h3><p>A common coding task has a few lifecycle steps, that look more or less like this:</p><ol><li>A developer is assigned to the task.</li><li>It’s “in progress”, meaning the developer is coding it at the moment.</li><li>The task is finished and a developer pushes it to a branch.</li><li>The developer sets up a code review / pull request.</li><li>The task is tested by QA engineers.</li><li>It is merged to the master branch.</li><li>Finally, it’s deployed.</li></ol><p>While in your case some of those might be missing or have different order, you should get the overall idea. Many of us, especially in early stages of our careers, tend to abandon their child in point 4. Why?</p><p>While the creative process of doing the task is interesting, other may not seem so. We tend to leave uninteresting parts of our work to others and get our hands on <em>the cool stuff</em>.</p><p>Other developers definitely <em>have to</em> do the review. QA engineers <em>have to</em> test your task. Someone <em>has to</em> merge it and deploy it.</p><p>Pushing the responsibility for those stages to others is like having a baby and then sitting at home waiting for a catering lady to come and feed the kid. Or waiting for a clothing company to come to your house and dress the child, after it was bathed by a kindergarten representative.</p><p>If you want the child to survive and want yourself to be recognized as a good parent, you have to take care of it.</p><h3>Own it!</h3><p>You are responsible for your piece of work during the whole mentioned lifecycle. You should take care of it unless it’s deployed to production, when your company releases frequently. Or — if a new version goes public every few weeks, months or years — when it’s in the master branch. But how?</p><h4>Progress updates</h4><p>First of all, depending on the project management tool your company/team has chosen, make sure you update the status of a given task as you go. This way, you keep your scrum master or a project manager happy and they don’t have to ask you every 2 hours about your progress.</p><h4>Pull requests</h4><p>Remember the 30/60 rule I mentioned in one of the previous posts? You can base your actions on a timeframe while dealing with pull requests as well. Let’s divide PR’s lifecycle into two stages — <strong>leave it </strong>and <strong>push it</strong> stage. It’s normal that nagging someone about your review instantly can be really frustrating if you do this too often. Your mates also need to focus and have some time to work without distractions. That’s why, we first go with <em>leave it</em> stage, which means waiting for someone to take a look on their own. Then, we follow with <em>push it</em> phase, which is all about asking someone personally.</p><p>The only thing that is tricky here is developing the framework for determining how long each phase should last.</p><p>It’s probably a good idea to drop a review link to a selected person instantly if it’s a hotfix. If it’s really urgent, leave your desk and explain the situation face to face. If it’s something that <em>just</em> needs to land on production soon, act after 2 hours. If it’s a feature, take actions after the half of the day. You can ask someone to give it a look next day if it’s something that can wait and you plan to deploy this in a couple of days.</p><p>Time balance depends on your deployment frequency and the importance of the task. Feel free to play with it. Ask your teammates about their reviewing system. Some people do this twice a day, some do this immediately, others do reviews only at the end of the day. That information can be useful to sort out these proportions.</p><h4>Testing</h4><p>If you pass your changes to QA engineers, make sure they know they have to test it and they can proceed with it. We use Target Process and have a “Ready for testing” stage in our process. I wrote a Slack bot which automatically notifies a responsible tester that there is some work that needs to be done. You can do this manually as well. If possible, make sure you know who tests it, that he / she is aware that it’s ready for testing. Then, get back at some point to ask about the results. It’s their green light you’re waiting for to proceed to the next step.</p><h4>Merging &amp; deploying</h4><p>This one really depends on the release model in your company. If it’s a SaaS company, you probably release often, sometimes a few times a day. In such case, your role ends when you merge the code, it goes live… and works.</p><p>A tip that can save your ass — try to get your lines to production as soon as possible or at least track when it will go online. There’s nothing more frustrating than your teammate calling you later saying that he / she just deployed your changes and they broke the entire production.</p><p>It’s simpler when you release rarely, as your part probably ends after merging to the master branch and you leave the rest to buildmasters.</p><h4>Keeping track</h4><p>If you use an advanced project management tool, like Jira or Target Process, there’s surely a way you can filter your sprint board to see only your assigned tasks. Make sure you take a look at them a few times a day to determine what actions should be taken. If Jira or TP scares you, set up a Trello board for yourself, define stages and keep track of your work there. Just make sure you reflect your changes in the official tool as well.</p><h3>…and chill out</h3><p>It may sound scary, but you can (and should) get used to owning your work and it won’t take much of an extra time if you master it. The advantages are endless — no teammates saying <em>you fuc*ed up</em>, no surprises on production, no delays because you forgot about your pull request. Better control of your flow and less people asking you “how about that thing you started…” are the other pros.</p><p>I hope I convinced you and I hope that owning it makes sense now. If you like it, heart it. If you have any doubts or comments, leave them below.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a73febe0e5a2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/uxpin-engineering/owning-it-101-a73febe0e5a2">Owning it 101.</a> was originally published in <a href="https://medium.com/uxpin-engineering">UXPin Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What makes a rockstar developer?]]></title>
            <link>https://medium.com/uxpin-engineering/what-makes-a-rockstar-developer-639800861008?source=rss-490524ef0a12------2</link>
            <guid isPermaLink="false">https://medium.com/p/639800861008</guid>
            <category><![CDATA[product-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[teamwork]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Kamil Wysocki]]></dc:creator>
            <pubDate>Tue, 03 Jan 2017 16:25:48 GMT</pubDate>
            <atom:updated>2017-01-03T16:44:24.720Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*mvS6wsUxe3p4xYDpGVpzRA.png" /><figcaption>Illustration: <a href="https://dribbble.com/adamzielonko">Adam Zielonko</a> / UXPin</figcaption></figure><p><a href="https://medium.com/@kamilwysocki/what-makes-a-good-developer-ce37b604b09c">In the previous post</a>, we came up with some traits characteristic for every good developer, and talked about two of them — <strong>good code quality</strong> and <strong>code predictability</strong>.</p><p>Now, we’ll cover next two —<strong> delivering on time</strong> and <strong>being communicative</strong>. These aspects are not so commonly seen even among senior developers and it’s important that every developer understands them properly.</p><h3>Delivering in satisfactory timeframe</h3><p>Based on my experience, that’s the trickiest part. And probably the most important one. The reason behind it is that a lot of developers have minds of Carl Sagan… meaning they easily get lost in time and space.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*IpU9vyHDCBcMmW0Lxct9qw.png" /><figcaption>Illustration: <a href="https://dribbble.com/adamzielonko">Adam Zielonko</a> / UXPin</figcaption></figure><p>You probably know a guy who can’t decide on a solution even after the sixth meeting. Or a guy who asked about his progress, says he’s <em>on it</em>, but he had to stop for few hours just to understand one <em>tiny</em> thing he came across. Or the one that conducted his research for few days to find out that the solution won’t work after trying to implement something. Or yet another one, who found a weird thing in code and spent too much time on trying to fix the imaginary problem.</p><p>That’s not bad, <strong>it actually means that they have the level of curiosity and ambition that makes them love what they do</strong>. This is really important in this job. But as it is with many other things — you’d better keep it under control.</p><p>You might think, <em>alright, I know where he’s going, I lose my time and the company loses money</em>. Yes. And no. Yes, the company loses money in some cases, but even more important aspect of a developer losing time on an irrelevant thing, is the impact it has on that particular developer.</p><p>Have you ever seen a cyclist who developed an award-winning form just by <em>thinking</em> and <em>reading</em> about cycling? Probably not. He might have read about cycling basics, maybe someone passed that knowledge to him. But then he got onto his bike and he kept cycling. That made him successful.</p><p>The first thing you need to understand (if you haven’t already) is that you gain experience and master your skills by <em>doing things</em>, not <em>thinking about them</em>. I’m not asking you to skip the research phase of your work. I’m just asking you to be reasonable about it. Get a basic overview of the topic, gather necessary information and resources you need to start, and jump into it. There’s no point in reading whole API’s documentation before you even try to connect. Some things will cause problems anyway, you can’t predict them in 100%, so don’t worry about problems that will pop up along the way. Sure, you need to know if your task is doable at all, but that’s the purpose of planning sessions or a good reason for having a software architect in the team.</p><p>Alright, but how does it influence you? Here’s an example. Let’s say you need to do a research on a topic and you can take two approaches:</p><ul><li>get the overall understanding in 1 day and start coding,</li><li>read the documentation for 5 days.</li></ul><p>If you chose the first one, you dive deep into the problem. On the day 2, you encounter first problems which you finally solve in the day 3. You improve the thing you do and solve more problems on days 4 and 5. It basically means that by acting as soon as you can, you have an extra week of gaining experience, which would be lost if you chose to read the docs for 5 days. This is the <em>fail sooner, succeed faster</em> rule which brings a lot of profit to your skill set.</p><p>Same goes for having discussions and debates on development stuff, approaches, possible solutions — just ask yourself if the result will justify the loss of time. If you’re not sure — probably not. Ask someone more experienced or more decisive for advice if you can’t figure it out.</p><p>Furthermore, losing time heavily influences your position in the company. Let’s be honest about it — thinking about problems instead of solving them may change the way people perceive you and your work, which probably won’t be beneficial in the long run. You’re not going to be trusted with tasks that require dynamics, experience in the system or exceptional solving skills, and that may lead to frustrations on both sides.</p><p>To sum up this part — go for it as soon as you can. This way, you gain more experience, things are done and you keep relationship between you and your company on a satisfactory, happy level.</p><h3>Communication</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*KftSkdvSw6dS1UHG0FgzhQ.png" /><figcaption>Illustration: <a href="https://dribbble.com/karolpodlesny">Karol Podleśny</a></figcaption></figure><p>Communication is a brilliant tool which can help you overcome any problems you get into, and will help you improve in the three virtues mentioned before. Not convinced? Let’s think about such cases:</p><ul><li>Not sure if you still need to improve the code you’re working on further (or how to do it)? Ask other (preferably more experienced) developer. He/she will be able to tell you if code quality is acceptable and will stop you from improving things that are already okay. If something isn’t right — you’ll get a piece of advice or at least a recommendation of the person whom you should talk to.</li><li>Need help to determine if the feature you made works properly? Ask a QA engineer. He/she usually knows the system better than you and can say what impact your change may have, or what possible traps lie ahead.</li><li>Not sure if you can actually do the thing you are asked to? Ask an architect or set up a meeting with your peers. Their experience and knowledge will help you to sort things out.</li></ul><p>Try talking with people. Turn off <a href="https://medium.com/u/26d90a99f605">Slack</a> for a while and walk around the office to chat with them. You’d be surprised how many interesting things happen when you’re not focused on your computer.</p><p>Basing on my own experience, there are also some elementary pieces of advice which can help you in communication:</p><ul><li>You can really get rid of almost every problem by talking with people. Finding the right person is a matter of some experience, but it definitely helps. And it’s really good to have a break from coding from time to time.</li><li>Don’t be afraid to admit to the lack of knowledge. This makes you more human, proves you know your skills and limitations and makes people feel you’re a partner, not a moron.</li><li>Problems with transparency? Not sure what your teammates are doing? Become a role model, share your status even when it’s not necessary. A simple chat message will do. You’ll be surprised how soon they’ll follow.</li><li>Stuck on a problem? Go with 30/60 rule — ask for help if you can’t solve a simple issue for 30 minutes and a hard one for 60 minutes.</li><li>Ask people for feedback about yourself. If they will be resistant to make it straightforwardly, ask your leader to gather that feedback for you.</li><li>Ask for people’s thoughts on solutions, views — this really can open up your eyes for a new perspective.</li></ul><p>Not everyone is a social beast — and that’s perfectly normal. The virtue of being communicative doesn’t mean you have to chit chat with every person in the office. That means you’re not afraid to work with people, talk to them, say what you think. It helps to save your time, build connections and improve your skills even faster.</p><p>A communicative developer is a developer who can handle almost every situation, either by himself or with the help of others. That’s why, companies know that good communication skills usually mean that a person can make things happen.</p><h3>Are YOU a rockstar developer?</h3><p>Did those points sound obvious? That’s totally great, because it probably means you are a marvelous developer. You’d be surprised how many code ninjas actually have issues with communication or can’t manage their time well. Similarly, many junior developers take detours on code quality or do it the other way round — spend too much time on polishing unnecessary stuff.</p><p>Go over those points once again, read my previous article, be honest and think whether you actually do those things the proper way. If yes — congratulations! If no — don’t worry, there are skills that come with time and practice. Think how you can overcome those issues. If you can’t think of any idea, comment below or send me a message and I’ll try to help you out.</p><p><em>I can share my tips for determining if the task I do is worth my time. If you’re interested, let me know in comments. And as always — heart it if you liked it!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=639800861008" width="1" height="1" alt=""><hr><p><a href="https://medium.com/uxpin-engineering/what-makes-a-rockstar-developer-639800861008">What makes a rockstar developer?</a> was originally published in <a href="https://medium.com/uxpin-engineering">UXPin Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What makes a good developer?]]></title>
            <link>https://medium.com/uxpin-engineering/what-makes-a-good-developer-ce37b604b09c?source=rss-490524ef0a12------2</link>
            <guid isPermaLink="false">https://medium.com/p/ce37b604b09c</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[product-development]]></category>
            <category><![CDATA[teamwork]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Kamil Wysocki]]></dc:creator>
            <pubDate>Mon, 19 Dec 2016 16:32:06 GMT</pubDate>
            <atom:updated>2017-01-03T16:43:52.340Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*_yeKNiZnCMWach5wfu9L9w.png" /><figcaption>Illustration: <a href="https://dribbble.com/adamzielonko">Adam Zielonko</a> / UXPin</figcaption></figure><p>I’ve met a lot of great software developers. Data transforming magicians, who can stack a bunch of lodash functions you didn’t even bother to read about, to split, join, manipulate and filter objects in one line of code. Backend Harry Potters, who provide necessary data and keep every operation secure, optimized and predictable. Front-end artists, who make your in-house designers’ wet dreams come true in few lines of code. You probably have met some of them as well.</p><p>But not every one of them is <em>good. </em>Not in terms of skills, no. <em>Good </em>as a co-worker, proving to be useful for the companies they work in. Why?</p><p><strong>Because a good developer delivers good enough quality code which acts in a predictable way, does so in satisfactory time and is able to communicate well.</strong></p><p>Simple as that? Not necessarily. Companies are here to make money. What they pay developers for is simply making profit. The profit in its broad sense — whether it’s a feature that earns new customers, an optimization saving money, or an improvement that helps to reduce a technical debt (it’s a long term profit which sadly, is sometimes ignored). On the other hand, developers invest their time to bring that profit. The time which is spent not only on finishing particular tasks, but also which has to be balanced between coding, communication, personal development and many more.</p><p>How to make sure you are not only skills-wise but you’re a good developer in general? Let’s get back to my definition and break it down. This time, we will focus on two virtues of a good developer which are the most common and are essential on every level of developer’s career.</p><h3>Good enough quality code</h3><p>This is probably the simplest factor to understand and you may perceive it as something natural. What I’d like to stress here is good <em>enough</em>. I studied automatic control, which taught me few things thanks to my thesis supervisor, who is an endless source of quotes . One of these is:</p><blockquote>A solution of a problem is good as long as it solves the problem on a satisfying level and the costs of this solution are justifiable.</blockquote><p>Which means — yeah, you got it — it is simply good enough.</p><p>How does it relate to software development? Imagine you developed a proof of concept of a method which transforms an object of random data. There are some conditions, some maps, some alterations. You clean up the code now, you merge some conditions. Yet, you still feel the code can be improved <em>somehow</em>. Maybe some more conditions can be merged? Maybe you could use an arrow function instead, and get rid of that nasty <em>return</em>? (Yes, I know, this is a simplified code case).</p><p>With your code, you want to reach a point where the code is:</p><ul><li>readable and maintainable by other human beings,</li><li>well written (well-structured, extensible, compliant with universal programming rules and company’s code styleguide),</li><li>efficient and reliable.</li></ul><p>That means you basically can stop working on a given task if you say <em>no</em> to questions like:</p><ul><li>will this change make the code more readable?</li><li>will the outcome be worth the time I will spend on it?</li><li>will this make it work faster or more reliable?</li><li>will this reduce a technical debt or at least won’t increase it?</li><li>will this improvement change anything for better?</li></ul><p>Ask your peers for help if you have problems answering those questions. It’s a good practice to ask a senior dev, your tech lead or CTO to check the code, whether it’s just taking a look at your screen or pushing your code to a review.</p><p>Keeping your code just <em>good enough</em> makes your company feel that the salary it pays you is transformed into decent, profitable work and not into countless hours of improving your code poetry skills. Your company is not an open source GitHub project which can be developed over years, and keeping that in mind will make both sides happy. You might be the best coder out there, but spending too much time on polishing things that don’t matter, won’t work in professional life. Not that you shouldn’t improve your skills — on the contrary, you should <em>always </em>strive to do that. Just do it wisely and don’t waste time on things that don’t bring any value.</p><h3>Code that acts predictably</h3><p>Predictability understood as reliability and maintainability is the aspect of programming that you care more about as you gain more experience and deal with other people’s code.</p><p>There’s nothing more frustrating than diving deep into the old code to fix a feature which doesn’t work properly for one user only. You do it to find out that there are no tests and the code leaves you with a huge <em>what the… </em>painted on your face.</p><p>Want to make sure people won’t use <em>git blame</em> against you and mention your person in ‘<em>@yourlogin is a c**t!’</em> mean tweets? Please, just say <em>yes</em> to questions like these:</p><ul><li>is the code safe and gives the desired outcome every time?</li><li>does it have automated tests if it needs to (a good QA engineer will convince you that in 95% it really does)?</li><li>was it tested by me?</li><li>was it tested by QA engineer, if necessary?</li><li>did I make the code easy to understand and read?</li><li>is the code extensible? (that kinda derives from good enough code principle)</li></ul><p>If everything is alright with those, your company will thank you and at least two people will sleep well — you and your manager. Thinking about those questions will minimize the risk that you’ll do the same thing twice, instead of spending this saved time for more interesting tasks. It will also help you to keep technical debt in check. This way, your company will know that your work can be trusted upon and someone else won’t be needed to cover up for your mistakes. And that, believe me, is a great value.</p><h3>And what about being a REALLY good developer?</h3><p>We covered two aspects of developer’s work that are really essential. You need to make sure you don’t have any problems with them, as they are the foundation of your work. If you want to read about next two: delivering in satisfactory time and communication 101, jump to my next post — <a href="https://medium.com/@kamilwysocki/what-makes-a-rockstar-developer-639800861008">What makes a rockstar developer?</a></p><p>Any comments, questions are more than welcome. Please heart this post if you liked it!</p><p><em>Big thanks to my first readers and proofreaders: Magda, Paweł, Bartek and Jerry, I owe you a beer!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ce37b604b09c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/uxpin-engineering/what-makes-a-good-developer-ce37b604b09c">What makes a good developer?</a> was originally published in <a href="https://medium.com/uxpin-engineering">UXPin Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>