Juni is a membership-driven learning platform designed to help each student discover and pursue their passions with joy

Juni

juni

Long ago, in an era when every junior could find a job and get an offer without much effort, I encountered situations that forced me to face the reality of the modern industry. It was a time when crowds were eager to enter the world of programming, but not everyone understood what to prepare for. A call from HR. It went successfully, and then I was invited for an interview. At the interview, there was a certain owner of the company named Elizar Viktorovich. However, he didn't ask any technical development questions but immediately started talking about the future job. It was strange; by that time, I had already had several real but unsuccessful interviews. Later, I googled this Elizar and saw a huge number of angry reviews from juniors on all open platforms stating that Elizar assigns tasks from freelancers but does not pay salary during the probation period, and after the probation period, he disappears. I did a test assignment for free, and the employer disappeared. The motives are really unknown. The task was simple but strange - to make a regular mobile application that reads data from JSON and shows a list of cards. The strangeness was that there were extra spaces and some letters from the Latin alphabet were replaced with Cyrillic :/; things that generally do not occur in practice. Honestly, it's not very clear what this test assignment is checking. I sent the task, but the employer didn't even read my messages. TWO months later, he replied: "We liked your test assignment; we will contact you for an interview." And then he disappeared... Another episode: a random call from a man from my city claiming that he was ready to hire me for a job from an ad I posted on hh.ru. He offered a salary in an envelope of 45 thousand rubles. When I refused, he started to criticize me and claimed that I was a fool who didn't understand what kind of opportunity it was. Doubts prevented me from accepting such a job offer. Today, when the market is flooded with juniors, deception and shady schemes have become commonplace. The recommendation I can give is that no reputable company will offer a job to a developer without a thorough technical interview. If something is offered without this, you should think about hidden pitfalls. The reality of the IT industry has changed, and now, it's important to be vigilant and ready for surprises. I hope my experience will help others avoid such pitfalls and make the right decisions on their way to a career in IT. What strange or unusual requests or tasks have you ever received during interviews or completing test assignments for work in the IT field?

How I Was Deceived When I Was a Junior Developer

*We will survive, believe me!* Something that all junior developers share, regardless of the stack they are working on, whether it's backend, frontend, mobile, JavaScript, C#, Angular, PHP, or whatever the focus of their work is: managing branches, making commits, and creating Pull Requests. One of the key factors to transform your career is to refine your communication with your team more and more. The clearer you are in presenting your ideas, doubts, and opinions, the more value you will have. So, as the idea of this text is to be practical, let's go to our main topics: ; ; and . Managing Branches Commits Pull Requests Managing Branches is a model for managing branches. The idea is to create, from the main branch, specific branches for the development of your project, complete the development of what you are creating, and merge it back into the main branch. Gitflow In Practice: Your task for the week will be to include a social login with Facebook in your project. What's the first step? Start your project from the main branch (main), switch to the branch where the project is being developed (develop), and from there, create a new branch for this task and work on it (feat/social-login-facebook). Only then do you start your work. When you finish your work, this branch will be merged into the “develop” branch. What are the most common types of branches? : It is the main branch, reflecting the most "stable" version of the product you are working on. Main : Developers use this branch to start their projects, and it serves as the base code. Develop : This branch is created from the development branch for specific tasks. It is considered a temporary branch that, upon completing its task, should be merged back into Develop. Feature : Similar to the Feature branch in that it's temporary, but it is used for immediate fixes. It can be created from the developed or main branches. Hotfix : This branch is considered a "pre-main." When various tasks are completed and a significant stage of development is finished, a release branch is created from the development branch. It serves more as a milestone for the type of update the main branch will receive. Release Ok, now that you have a better understanding of how branches work, how can you apply this in your daily routine? Free extensions are available in the Visual Studio library, such as , which makes all these branch changes visible and distinct. Let's see: Git Graph Through Git Graph, you have access to the graph itself, showing the progression of branches, the branch description, the creation date, the author, and the commit ID. Git Graph is not only designed for a graphical view of the branching order but also for understanding the commits, where they are made, and how they come together. There is also a specific way to name your branches to adhere to this flow, typically using a prefix like feature/, hotfix/, or release/. You can read more about the topic . here In addition to Gitflow, there are other branch management strategies, such as GitHub Flow, GitLab Flow, OneFlow, and Trunk-Based Development. If you want to delve deeper into the subject, you can read it . here Commits Commit is the tool that allows you to explain the intent behind the changes you made in the code. They should be concise and descriptive, with a clear and specific purpose. Commits act like checkpoints. In addition to explaining the purpose of your changes, they also serve as a way to roll back in case your code is not approved, allowing you to revert to the previous commit. But just like GitFlow, there are also commit standards. The one I've been using is . Conventional Commits Using Conventional Commits makes its purpose very clear since every commit starts with either chore, feat, fix, refactor, docs, perf, style, test, build, ci, or env: : Updating tasks that do not cause changes in the production code but involve tool changes, configuration changes, and libraries. chore : New features or any other new implementations to the code. feat : Bug fixes. fix : Used for any changes that are made in the code but do not alter the final functionality of the impacted task. refactor : Inclusion or modification of documentation files. docs : Changes to improve performance. perf : Formatting changes in the code presentation that do not affect the code's meaning. style : Adding missing tests or fixing existing tests. test : Changes that affect the build system or external dependencies. build : Changes in CI configuration files and scripts. ci : Modifications or additions to configuration files in continuous integration (CI) processes and methods. env Since the commit is a way to create a checkpoint, it should contain a fragment of your task. In our case, you could divide the task of adding login through Facebook into the following commits: Creating a relationship with Facebook to receive a token feat: Add integration with Facebook to receive the token Creating necessary permissions on Facebook feat: Configure permissions on Facebook for integration Creating a component to perform the request feat: Implement component for the request to Facebook Creating verification of the Facebook token with the user in the project feat: Add verification of Facebook token with the user in the project Testing integration with Facebook test: Perform integration tests with Facebook Creating documentation for the integration with Facebook docs: Add documentation for integration with Facebook By making commits in this way, when you create your PR, it will make your life easier, as it becomes clearer what should be included in the PR since you have already described everything you did in the code through the commits. Now, what tools can help you maintain standardized commits? and . Commitlint Husky With Commitlint, you can create a commit verification filter that needs to follow a specific format (conventional commits) to be effective. And how do you apply to ? By using and Husky, which compare the established rules and what you wrote. If the pattern is not followed, it prevents the creation of the commit, asking you to correct it. It is essentially an automation of the commit verification process, limiting their size and allowing them to be divided into a short message, scope, and commit description (if necessary). Commitlint Commitizen For the application of these tools, I recommend these two texts: 1 - Why Should you use Commitizen + Husky for conventional commit and have organised lint 2 - Como adicionar hooks de commit ao Git com Husky para automatizar tarefas Pull Request (PR) And now what? You created your branch, completed the defined task, created checkpoints with commits, and now you need to make the PR to add your branch to the developed branch. How to do it? A Pull Request is the way you ask to merge your branch into the develop branch. It is the method we use to present your work to be reviewed by other developers and approved. The main purpose of the PR is to present what has been done, validate the work, or point out changes that need to be made and include your code in the development branch. As a communication tool, although it does not have a convention like the previous ones, there are some ideas to keep in mind when making your PR. Your PR should be based on WHY, WHAT, and HOW. : Why your PR is necessary, and what problem caused your need. WHY : Describe what your PR does, not in a technical way, but what the practical effect of your code change is. WHAT : This is the space you should use to make it clear, in a technical way, what changes you made. You should use your commits as a guide for what will be explained, which files were altered/created/deleted, how it happened, and why it happened this way. That would be the basic necessity. HOW Now, two points to pay attention to: PRs should contain between 200 and 400 lines of code change; more than that, there's a possibility that an error may go unnoticed. : The number of code changes Your PR is the moment to explain what you did, but it doesn’t mean writing a book. Just like with commits, you have to focus on being concise and clear. Conciseness: Finally, there is other information you can add to facilitate the interpretation of your PR, such as the type of changes made, screenshots or videos of the effects of your change on the project, adding the link to the Task you resolved, some form of checklist, and a section for additional information you may want to add. You can find a screenshot and the to the example PR template I usually use. link I also recommend Kara's on the subject, which is much more comprehensive than this. article : Some teams may have their template; if yours doesn't, you can check if it's possible to add one. itself provides a detailed description of how to do this. PS GitHub Conclusion Knowing how to use and create branches, commits, and pull requests are basic concepts, but not everyone gives them the importance they deserve. Although this is not directly related to code, understanding how to use branches, commits, and pull requests is fundamental and highly valuable because it's the way developers can communicate, explain their work, and receive feedback for improvement. This is the first text in a series of guides that I intend to create. As I continue learning in my day-to-day, I'll keep publishing these ideas.

Your Junior Dev Survival Guide to Managing Branches, Commits and PR

Java Testing Frameworks: Choosing the Right Tool for the Job - JUnit, AssertJ and Hamcrest

The Basics of Developer Hierarchy First, let's delve into such a convoluted narrative. What sets a Junior apart from a Mid and a Senior developer? You need to understand that in the real world, there isn't a clear-cut demarcation because it varies significantly based on the company's perception. In one place, , while with the same set of skills, you could be considered a Mid elsewhere. And in a third setting, you might even qualify as a Senior. So, the best definition I've come across goes something like this: you might be a Junior 👶: A Junior is essentially a beginner in the field of development who can handle basic tasks. However, they often need assistance to complete a task entirely because they lack the experience. Juniors tend to tackle tasks to the best of their abilities but may not excel in optimization. Junior Developer 🧑‍🚀: A Mid-level developer is more independent and experienced. They can tackle tasks on their own, understanding the project's specificities, system architecture, and overall project structure. While not perfect, they can complete assigned tasks without external help. Mid-level Developer 👴: A Senior developer is the one with the most experience. They can start from scratch and execute a project to perfection. They grasp the project's specificities, choose the optimal technologies, manage team interactions effectively, and understand how to achieve the project's goals efficiently. It's the highest level of technical expertise. Senior Developer Here's an amusing definition as well: A Junior developer is one who has acquired basic knowledge and now feels invincible, believing they can implement anything. Then, as you gain a bit more experience to the Middle level, you realize there are things you don't understand. You lose that invincibility feeling. But, Seniors are in a constant state of realizing just how much they don't know, yet they don't fret because they have the experience to quickly figure things out. The distinctions between Junior, Mid, and Senior developers can be somewhat blurry and are subject to variation. It's essential to understand that these labels are relative and depend on the context and expectations of the company you work for. 🎯💼 Dealing with the Real World Let's get down to the nitty-gritty. In the developer's universe, there's more to it than just coding. Conflict Resolution & Communication🤝 In the real world, you're going to face conflict. It's unavoidable because developers, like any other humans, have different values, interests, and perceptions. But, as a Mid, it's your duty to learn how to navigate those rocky waters. You've got to be the peacemaker when conflicts arise, all while keeping the development ship sailing smoothly. Communication is another crucial skill in this game. Even if you're an introverted code wizard, you need to communicate effectively. If a problem crops up, don't keep mum – speak up and discuss it. Timely discussions prevent issues from blowing up later on. So, whether you're an introvert or an extrovert, communication is your ticket to success. More Essential Skills📚 For Mids, the path to success isn't all about coding. You need to start understanding business requirements and what the clients want. This helps you find more efficient solutions to problems. Being an independent thinker and a self-learner is also a must. You've got to keep up with new technologies, methodologies, and approaches. – knowing how to assess the time it takes to complete a task is crucial. You can't be a Mid without mastering this skill. Sharing knowledge with your team is vital, too. If you can explain complex concepts in a way a newbie developer can understand, you're golden. It's all about making the learning process smoother.📖 Mid-level developers should also hone their estimating skills The Mid's Transition🚀 As a Mid, you'll likely transition into more managerial roles. You'll be responsible for project management, delegating tasks effectively, and making sure your team communicates seamlessly. It's all about leveling up and passing on your wisdom to the newbies. In summary, being a Mid-level developer is like balancing on a tightrope. You've got to keep your technical skills sharp while diving into the world of business requirements, communication, and self-improvement. But remember, the more you learn, the more valuable you become to potential employers. So there you have it, the lowdown on the developer hierarchy. Whether you're just starting your coding journey or climbing the ladder, there's always something new to learn and always a new challenge around the corner. Embrace the journey, and keep coding!

Discover the Nuances of Junior, Mid, and Senior Developers in the Tech Industry

A Detailed Roadmap to Take You From Junior to Senior Web Developer

Junior developers often find themselves caught in a dilemma between delivering code quickly and ensuring high code quality. While speed of delivery is important to meet deadlines and keep up with the pace of the industry, quality is crucial for maintaining software integrity and avoiding technical debt. code In this article, we will explore the challenge that junior developers face in finding the right balance between these two opposing priorities and discuss strategies for achieving both speed and quality in their work. The Importance of ‘Why?’ and Consequence in Development Good developers and development teams answer questions in the context of solving problems. Answering ‘Why?’ reveals whether actions correspond to an end goal. Understanding consequences defines a good developer and distinguishes technical debt from bad code. Ignorance of consequence leads to unmanaged complexity that stalls delivery. Pushing ‘Why?’ and enhancing consequences ensure continuous value and delivery, rather than simply producing or building up technical debt. Tips for Striking the Right Balance You do not necessarily need to be “Quick & Dirty” or “Clean & Slow.”​ Whenever you speak about quality, there is an inherent assumption that it takes longer. Don’t get me wrong--most of the time, if you need to have a clean code, you need to invest some time in it, but not necessarily all the time. You can choose the right balance between the two. There will be times when velocity takes priority and others when quality is needed to avoid future stupid, unexpected problems. So, it’s like this: getting the balance right between meeting deadlines, shipping features, and writing the best code possible is seriously tricky. Some folks think that the need to get things done and keep clients happy means that clean code patterns take a back seat, while others believe that quality code should be priority number one and that by prioritizing it, you can actually work faster in the long run, even if you miss short-term deadlines. This is why you need to stop seeing it in black and white and start to see the shades between them. Embrace Everything-as-Code Developers are less likely to make mistakes when testing or deploying software, for example, when the processes are codified. At the same time, managing everything through code also increases software delivery velocity because it allows processes to be as automated as possible. So, the point is to try not to take unnecessary extra steps and replace whatever you can with a code-based approach wherever possible. The more you’re in the actual code, the faster your performance and the better your code will be. Stay Humble & Manage Expectations As a junior developer, it’s expected to make mistakes and produce inconsistent work while learning. Seek when needed, but don’t rely on it entirely. Try to figure things out yourself first and use available resources before asking for help. Take criticism graciously, as code reviews are not personal. Keeping an open mind and considering different approaches is key to becoming a successful developer. senior advice Embrace Small Developer Teams Smaller teams can be more effective for junior developers. This is because smaller teams can often provide more opportunities for learning and growth, as well as more opportunities to contribute to the project. Additionally, smaller teams may be less intimidating for junior developers, as they may feel more comfortable asking questions and seeking help from their colleagues. I am not saying that if you are in a big team, you should quit and search for another place to be in a smaller team, but small teams can give you the key to having the balance faster. Use everything at hand. I actually used to be against using you have for junior developers, and the reason was simply that it could be inaccurate or misleading sometimes, and it could also kill your Googling skills (I think that term will be gone in the next few years 😊 and be replaced with “prompting” or something), So whether you like it or not these tools are here to stay. Chat-GPT or any available AI tool I highly recommend using them for simple, boring tasks so you can gain more time to focus more on your code quality. Conclusion While it is important to write clean, efficient code, it is equally important to meet deadlines and deliver working software. By prioritizing communication, seeking feedback, and continuously learning and improving, junior developers can navigate this challenge and contribute to successful projects. With the right mindset and approach, balancing code quality and speed of delivery can become a strength rather than a weakness. Sources: Speed vs. Quality in Software Delivery: 5 Tips for Striking the Right Balance For modern developers, software delivery speed tends to be the name of the game. To delight users, meet business goals… www.itprotoday.com On the Balance of Speed and Quality Fostering faster development without sacrificing quality. medium.com The Most Common Misconceptions Amongst Junior Developers | Wasp · 6 min read High code quality only indirectly affects users. The main purpose is to keep development velocity high… wasp-lang.dev Also published . here

Junior Devs, Let's Talk About Balancing Code Quality and Your Speed of Delivery

You've probably been there: a newbie in the tech industry, eyes wide, in front of a codebase that looks like a maze, full of uncertainty. Now, you're a mid-level developer, a seasoned coder with a few laps around that maze under your belt. One crucial role you'll play is that of a mentor to junior developers, shepherding them as they navigate the maze for the first time. As Uncle Ben once said to Spiderman, "With great power comes great responsibility." In this case, the 'power' is your experience, and the 'responsibility' is to foster the growth of your less experienced team members. But don't worry! Here's your guide on how to mentor effectively, contribute to the team's growth, and mold the next generation of tech talent. Why Mentorship Matters Mentoring is not just beneficial for the mentee; it's a win-win situation. By sharing your experiences, insights, and tribal knowledge, you're helping junior developers accelerate their learning curve. In return, mentoring offers you an opportunity to refine your communication which helps you clarify and solidify your own understanding. More broadly, mentoring gives provides a fresh perspective, improves your leadership skills, and contributes to a collaborative team culture. about your craft Mentoring Strategies for Mid-Level Developers Every junior developer is unique, with different strengths, weaknesses, and aspirations. Understanding their background and career goals will help you tailor your mentoring approach to meet their needs effectively. Understanding Their Background and Goals: For learning and growth, it's essential to create an environment where junior developers feel comfortable asking questions, making mistakes, and seeking help. Building trust takes time, but it's the foundation of a successful mentor-mentee relationship. Fostering a Safe and Trusting Environment: Coding skills are crucial, but soft skills are often what distinguish successful developers. Teach them how to communicate effectively, manage their time, work as part of a team, and solve problems. Remember, you're not just mentoring a coder but a whole person. Teaching Soft Skills: Feedback is the breakfast of champions. Constructive feedback helps junior developers identify areas for improvement. However, it's not just about pointing out the areas they're lacking but also highlighting what they're doing well and should continue. Providing Constructive Feedback: Remember the old saying, "Show, don't tell." When a junior developer encounters a problem, instead of just giving them the solution, walk them through the problem-solving process. This way, they'll learn how to approach similar issues in the future. Demonstrating Instead of Directing: In our industry, the only constant is change. Continuous learning is a must. Inspire them to keep up with the latest tech trends, attend workshops, webinars, and read. Learning should be part of their daily routine, not just something done when a problem arises. Encouraging Continuous Learning: While ambition and drive are necessary, it's essential to encourage a healthy work-life balance. Share your strategies for avoiding burnout and maintaining productivity without sacrificing personal well-being. Promoting Balance: Mentorship Challenges and Overcoming Them Mentoring isn't always easy. You may face challenges like time constraints, lack of trust, or communication gaps. It's important to remain patient, empathetic, and flexible. Also, seek feedback from your mentees. Their feedback can provide valuable insights into improving your mentoring style. The Ripple Effect of Mentorship By stepping up as a mentor, you're setting a positive example for junior developers. When they advance in their careers, they'll likely pay it forward by mentoring the next generation of developers. This ripple effect contributes to a culture of continuous learning, collaboration, and mutual support in our industry. Embrace mentorship. No, you don't have to be a level 10 expert to be one. A level 3 can successfully offer value to 1's and 2's. Yes, you'll encounter challenges, but the rewards of witnessing your mentee's growth, enhancing your own skills, and contributing to a nurturing team culture far outweigh them. As they say, the best way to learn is to teach. Also published . here

Mentoring Juniors: Tips for Mid-Level to Senior Developers

Hello, community! I’m Anna Naumova, and I’m really passionate about Android Development. Currently, I work in a company that develops a mobile app - a messenger with audio and video calling functions, and I’m actively involved in the development of many useful app features. In this article, I’d like to tell you in general about - a distributed version control system and its most useful commands that I use in my daily work. I’d like also to explain why a Junior Android developer needs to master these commands even before he gets his first job. I will also talk in general about how a workflow is usually arranged in most companies. Perhaps this article will be helpful to Junior Android Developers who are in the early stage of their career. Git Now, looking back, I can say with confidence that if I had mastered Git earlier, my adaptation to the company would have happened much faster. When I learned how to use Git competently, the quality and speed of my work increased significantly. The reason for publishing this article was my daily observations over several years. Talking to who are just looking for their first job, I’ve noticed that they often underestimate the importance of the Git tool. Preparing for their job interviews, they often carefully study fundamental concepts (SOLID, principles of object-oriented programming, data structures), mobile development technologies (working with a network, databases, multithreading, etc.), prepare detailed answers to common interview questions, learn the algorithm complexity,  but at the same time they usually have absolutely no idea about the workflow. To my way of thinking, this approach is wrong. Once a candidate accepts a job offer, he becomes a member of a team, and every team has its own specifics and rules to follow, and Git is an important tool for organizing code work in a team. Junior Android Developers First of all, one should note here that I am in no way detracting from the importance of knowing the fundamental concepts of programming. In my opinion, understanding these concepts is a very important skill for being a successful Android Developer. This is a base, a skeleton, on which all further study of the remaining programming skills is built. In my opinion, that’s why questions about the basic principles of object-oriented programming are very often asked at job interviews. If a candidate understands the basic principles of programming well, then no doubt it is much easier for him to . However, it is equally important, in my opinion, to understand a company workflow when many distributed teams work on one product and write a lot of code. For most cases, knowing a few basic console commands and hotkey combinations will come in handy. I have been using these commands and hotkeys every day in my work for several years, and it makes my work convenient and saves a lot of time. switch to a new technological stack It should be noted that at the initial stage of a career in mobile development, a Junior Android Developer should not study Git deeply. In my opinion, it is much more useful to understand the main principle of how Git works than to learn a lot of complex commands. For most daily tasks, knowing a few basic console commands and hotkey combinations is enough. Even now, after several years, I have been using these commands and hotkeys every day in my work for several years now, and it makes my job convenient and saves a lot of time. The Git system can be loosely compared to a tree. This tree stores the entire commit history. There is the main trunk of the tree - this is a branch with the actual code, which is usually called "master." This branch contains the overall result of the team's work. Below you can see a good visualized example: Usually, working with the project code in a distributed team according to the following scheme: A developer gets a task (where he should implement a certain feature, fix a bug, etc.)., which is assigned a number. Execution of all project tasks is tracked in a project management tool (for example, Jira). Until the developer has taken the task to work, it hangs in the status. As soon as the developer takes the task to work, it goes into th status. "ready for development" e "in work" The developer will perform this task in a separate git branch, which needs to be started from the master branch. To do this, you can open a terminal in Android Studio and run the following git commands: - switch to the master branch Git checkout master - "pull" the current code from the master branch, which is located on the remote repository. Git pull (create a new branch and switch to it immediately). Note that, usually, the branch number corresponds to the issue number. Git checkout -b “your new branch name” to make sure you're on the branch you expect. Git status Let's say that you completed a task and want to push your changes to a remote repository for review. To do this, you can run the following commands (in the Android Studio Terminal or using keyboard shortcuts): - Format code so it looks nice and is easy to read for other developers Ctrl+A+L ​​ (highlight code) Ctrl + A (or "git add" in the terminal). This command will add your code to Git Ctrl+Shift+A (or "git commit" in the terminal). This command will commit the changes in the code. Don’t forget to write your commit message. Ctrl + K (or "git push" in the terminal). This command will push your changes to the remote repository. After that, the Android Developer can change the task status from “in work” to “in review.” Ctrl + Shift + K A tip: before I commit and push my changes, I always open the tab in Android Studio in the top left corner, where all the changes in the code are visible clearly. There you can once again check all the changes made and delete unnecessary ones. And if you suddenly need to switch to another branch without making a commit, you can use the command in the terminal. Then the changes will be temporarily hidden. If you need to show these changes again, this can be done using the command. Changes git stash git stash apply Once your changes are pushed to the remote repository, other developers in your team can see them and provide feedback - agree or disagree. Following these remarks, you need to fix your code and push your changes again. Once you have peer approval from all of your colleagues, you can merge your changes into the master branch of the repository using the button in your common work repository, ex. . Thus, changes in your branch will be merged into the main branch of the remote repository - master. After that, your task status can be changed to ” Done! merge GitLab “ready for test. If you need to update your project, commit and push your changes, you also can use the bottom in the top right corner of Android Studio. If you need to merge a branch from a remote repository into your current branch, you can run the following commands: Git checkout “name of the branch you want to merge into your branch.” Git pull ex: Git merge master. Thus all the actual changes in this branch from the remote repository will be merged in your branch. Git merge “name of the branch you want to merge into your branch.” In Git, you can make changes from one branch to another in two ways: , which I mentioned earlier, and . With the rebase command, you can take all the commits from one branch and apply them in exactly the same order to another branch. merge rebase The second method ( ) has an advantage over merge - it allows you , giving that history the look you need. rebase to rewrite the history of the branch If you don't need to pick up all the commits but only need some, it's convenient to use This method takes the changes made by a single commit and tries to reapply them as a new commit on the current branch. This feature is useful in a situation where you need to pick up a couple of commits from another branch rather than merge the entire branch with all the changes made to it. cherry-pick. These are the basic Git commands that I use actively in my daily work. In my opinion, they are quite enough for most tasks. But sometimes, a developer has to deal with more complex cases. If you want to learn Git in depth and master this technical tool more professionally, I can safely recommend the following resource: dangitgit.com I really hope that my article was useful to everyone who is actively interested in Android development and would like to master such a useful technical tool as Git. I wish you success in learning!

The Most Useful Git Commands for Junior Android Developers

Imposter syndrome can be a common challenge for Junior Developers. It's the feeling that you don't belong, that you're not good enough, and that any day now, someone will find out that you're a fraud. These thoughts can be demotivating and can hold you back from achieving your full potential. However, the good news is that you can learn how to overcome imposter syndrome in the workplace with the right mindset and strategies. https://youtu.be/LG-dU8rW2xg Recognize Your Own Accomplishments It's important to recognize your accomplishments and celebrate your successes, no matter how small they may seem. Take the time to reflect on what you've achieved so far in your career, whether it's a successful project, a new skill you've learned, or positive feedback from colleagues. Write down your accomplishments and keep them in a place where you can see them regularly, such as a sticky note on your computer screen or a note on your phone. This will help you remember your achievements and boost your confidence. Embrace Learning Opportunities It's normal to feel like you don't know everything. But the truth is, no one knows everything, and there's always something new to learn. Embrace learning opportunities, whether it's taking on a challenging project or attending a conference. This will help you grow your skills and knowledge, and it will also help you realize that everyone has something to learn. Connect With Others Connecting with others in your field can be a great way to overcome imposter syndrome. Attend meetups, join online forums, or find a mentor who can offer guidance and support. Talking to others about their experiences and challenges can help you realize that you're not alone in your feelings of self-doubt. You may even find that others look up to you for your unique perspective and skills. Practice Self-Care Taking care of your physical and mental health is important for overcoming imposter syndrome. Make sure you're getting enough sleep, eating healthy, and taking breaks when you need them. Exercise can also be a great way to relieve stress and improve your mood. Additionally, consider talking to a therapist or counselor if you're struggling with imposter syndrome or other mental health issues. Reframe Negative Thoughts When you start to feel like an imposter, try to reframe your thoughts in a more positive light. Instead of thinking, "I don't know what I'm doing," try thinking, "I'm still learning, and that's okay." Instead of focusing on your mistakes, focus on what you've learned from them. Remember that everyone makes mistakes, and they're an opportunity to grow and improve. Imposter syndrome can be a challenge for Junior Developers, but it can be overcome with the right mindset and strategies. Remember to recognize your accomplishments, embrace learning opportunities, connect with others, practice self-care, and reframe negative thoughts. By doing so, you can boost your confidence and achieve your full potential in the workplace. Learn More Tips On How To How To Overcome Imposter Syndrome in the Workplace With My Tech Career Newsletter! Get Valuable Learning Resources Delivered To Your Inbox Every Wednesday! You can learn more tips on how to overcome imposter syndrome in the workplace for Junior Developers, Senior Developers, Lead Developers, Project Managers, and Tech Leadership in my . This newsletter will give you insight into multiple stages of your career so that you can form your career plan, overcome learning blockers, and stay competitive in today's crowded job market. It includes featured content from authors and influencers in my network to help you navigate your career and learn new skills. today and set yourself up for career success! Tech Career Newsletter Subscribe Also published . here

How To Overcome Imposter Syndrome as a Junior Developer

The Noonification: My New Junior Developer Kinda Sucks (5/12/2023)

That developer is ChatGPT, and I have a love-hate relationship with it. There are so many articles about AI nowadays, so I’ll try to keep this one short. TL;DR: Using ChatGPT to code is like having a Junior developer under you. They can get the code 80% there, but you’ll need to review practically every line. The Scenario I have to admit that there are plenty of ways you could use ChatGPT to help write code. It’s probably better at some of them and worse at others. For example, I’ve heard plenty of people using it as a search engine. I personally find that a bit questionable. It’s not that hard to find documentation or even answers through a search. I use which helps to cut down the fluff. Kagi On the contrary, using ChatGPT, how are you supposed to know if the answer is true? On the other side of the spectrum, there are plenty of people using it as a glorified auto-completion. Something like . I can see that being useful. Github Copilot The scenario I’ve chosen is: Converting my code from to . chakra-ui tailwindcss Why? There are plenty of resources for both technologies, especially Tailwind (and of course, HTML). It should have plenty of data to work from. It is very possible to create a program to do this. While there may be plenty of edge cases, the functionality itself is straightforward. chakra-ui is inspired by tailwind, so it inherits a bunch of things that can be easily transferred. It is something I need to do. So it’s a real use case that someone else might encounter. Prompt Engineering Is a Chore Looking around the field, it seemed like prompting well is the difference between getting good or mediocre results. I’m not the best at this, but I did some research and tried my best. I made sure to use multiple prompts to get it to a good state. Only pasting my code whenever it seems like it knows it should only convert my code. Honestly, this part could be improved. Between the UI and the interaction, it’s quite a chore to use: It can take some time for it to reach the desired state Between me thinking about what to write, then waiting for it to respond and finish writing, it gets quite annoying to do this work. It’s inconsistent It doesn’t help that you can’t always reuse the same prompts. ChatGPT has some randomness to it, so I had to tweak the prompt every single time. Copy-pasting a prompt that worked previously didn’t help. It’s very easy to get out of the desired state The above is fine if it’s a one-time thing. But I found that it’s very easy for the AI to forget everything after the first code conversion. The most repeated success I had was 3 times I believe. Beyond that, it returned completely unrelated things like explaining what my code does. Token is quite a limiting factor There’s only so much code that it can produce due to its token limit. You can check the . It’s not very friendly for code. Below is an example of one of its outputs. Each different color represents a token. tokenizer here to see how it calculates the tokens Because of this, I have to split the conversion into multiple steps. Otherwise, the generation will stop in the middle. Telling it to continue doesn’t work most of the time. Combined with the points above, this quickly becomes a chore to do. All in all, the feeling I get is that I don’t want to write English. If I already have to write something, I’d rather directly write code that works. I can see prompt engineering being a key skill to have in the future. Similar to how knowing how to search is a key skill in today’s world. The Output Is Not Too Bad For all the work it took, ChatGPT did output some pretty impressive code. Here’s some comparison between the original and the result: As you can see, it did the job decently well. The Good The structure is brought over pretty well Other than the details, the HTML structure is quite similar to the original. The spacings are off, but the overall layout remains. The text content doesn't change The content itself was handled well. Even though I had to double-check all of them, none of it was changed. The only exception is those derived from JS. The Bad It had random classes There are plenty of classes that don't do anything. Some were changed, and some others were invalid tailwind classes. There are plenty of tiny differences The UI looked as if a library was just upgraded, and someone forgot to migrate the code. In this case, it’s because ChatGPT randomly changed the values of the classes. For example, a of 3 to 4, or changing the from bold to normal. The details were all wrong. padding font-weight It doesn’t work half the time The screenshots above were those that I can directly compare. In reality, the results were either incomplete or just wrong enough that I had to make many changes to get it to work. And because of that, I can’t compare it side by side. There’s simply nothing I can compare with since the code doesn’t run. It’s Like Reviewing PRs Instead of Writing Code What’s great about this is that I have something to work from. Thankfully, the work itself is very straightforward. It’s easy to spot errors. The mapping between the classes from chakra-ui and tailwind is almost one-to-one. It’s only tedious because the syntax is different. But this approach is more akin to reviewing PRs. I had to scan through the whole code to make sure everything is done correctly. It looks alright at first glance. But there are many gotchas once you work with it and pay attention closely. It brings this false sense of security which made me a bit frustrated once I found out about all the flaws. A big part of it is code that is interpolated from other codebases. It doesn’t look terrible, but it’s not what I wanted. There are even some alarming changes like changing the heading from h2 to h1. I can only assume it did this because of the content. . And now I have to review and fix it without being able to tell them to fix it themselves. It felt like a junior developer slapped something together and didn’t test their code And this is awful. I already have my fix of reviewing PRs at work. Now I have to do it too for my own projects? No thanks! Hopeful Future While I don’t think it’s anywhere near there yet, I do think AI will be helpful at some point for development in the future. Whether the answer is LLMs, who knows? Token limits are constantly increasing I’ve held off finishing this article long enough. During that time, there are plenty of announcements of the token limit being increased. While I’m not sure if it’s public, paid, or whatever, this is great to see. Prompting UX should get easier with time With ChatGPT plugins and better integration, issues like remembering state & consistency should be improved. Hopefully, that’ll lower the effort needed to get useful output from ChatGPT. In the meantime, I completed the other half of the migration manually. Was it faster? Well, who knows. It felt about the same. But writing it manually did feel a whole lot better.

My New Junior Developer Kinda Sucks

আমার নতুন জুনিয়র ডেভেলপার কাইন্ডা সাক

Mein neuer Junior-Entwickler ist irgendwie scheiße

Mi nuevo desarrollador junior apesta un poco

Mon nouveau développeur junior est un peu nul

मेरा नया जूनियर डेवलपर किंडा बेकार है

私の新しいジュニア開発者はちょっとひどいです

내 새로운 주니어 개발자는 정말 형편없어

Meu novo desenvolvedor júnior meio que é uma merda

Yeni Yardımcı Geliştiricim Biraz Berbat

Nhà phát triển cơ sở mới của tôi Kinda Sucks

我的新初级开发人员有点糟透了

Junior by Robert Abernathy is part of the HackerNoon Books Series. Read this book online for free on HackerNoon! : Junior Title : Robert Abernathy Author : Weiss Illustrator : August 28, 2015 [eBook #49809] Release date : English Language Table of Links Junior About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Robert Abernathy (2015). Junior. Urbana, Illinois: Project Gutenberg. Retrieved October 2022 https://www.gutenberg.org/cache/epub/49809/pg49809-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at www.gutenberg.org , located at https://www.gutenberg.org/policy/license.html.

Junior by Robert Abernathy - Table of Links

I sat down with some of my co-workers at Confluent to ask what the most pertinent Apache Kafka interview questions were for this year. A wide variety of questions surfaced, from the open-ended basics to advanced challenges. Then, I took notes and organized the answers. While the questions asked in a real-life scenario would differ widely, depending on whether the role was on a data team or engineering team and whether the candidate was junior or senior, I did my best to emulate the questions by providing answers for different levels. This post focuses on the questions that surfaced for junior-level applicants. If you’re a junior-level developer who’s looking to level up their Kafka knowledge for an interview, I hope you find this helpful! What Is Apache Kafka? Apache Kafka® is an open-source distributed event store and stream processing platform. What Is an Event? An event is a key/value pair representing a thing that happened – it could be a webpage click, a rideshare app request, or a thermostat adjustment. What Is a Topic? A topic stores events. Its underlying data structure is a log, which, unlike a queue, stores an immutable series of un-deletable events. What Is a Partition? Topics are broken up into partitions. Each partition can live on a different node in a cluster of servers, which enables low latency and high throughput. Each partition has a default replication factor of 3, which makes partitions highly resilient. What Is a Broker? A broker is a server that is responsible for message storage as well as metadata storage. For example, brokers store information about the latest #offset for the consumer to access. What Is a Producer and What Is a Consumer? A producer writes messages on a Kafka topic, and a consumer reads those messages. Producers are responsible for event assignment to partitions as well as data compression. What Is an Offset? An offset is the logical position of a record in a topic’s partition, assigned by the broker when storing the record. Consumer clients keep track of offsets so they can pick up reading from the last successfully processed one when resuming work from being offline. What Is a Consumer Group? When consumers share the same Group ID, they belong to a consumer group. This group splits the work of message consumption. Consequently, 2 consumers in the same group cannot read from the same topic. They must be in separate groups to do that. What is Message Acknowledgment? When consumers read a message, they send an acknowledgment to the Kafka broker. You can configure different settings on the producer depending on whether you want to wait for this message acknowledgment before sending a new event or not. What do People Use Apache Kafka for? What Is It Good At? Kafka is used for building real-time data pipelines. At LinkedIn, where it was invented, it was used to track site user activity. It’s also used for metrics, stream processing, event sourcing, and as a commit log. How Does Apache Kafka Provide Fault Tolerance/Durability? Each partition has a replication factor of 3 and is stored on 3 different servers. That means if a server goes down, there will still be two replicas available. What Is a Connector? Kafka Connect itself is a framework that makes it easier to write the code you need to connect to data sources and sinks. A Kafka Connector, on the other hand, removes some of the hassle and boilerplate code you’d have to write to connect to different data sources and sinks. What Are Different Partitioning Strategies, and How Do They Affect Ordering? We know topics are split into multiple partitions and that events are sent to topics. How are events assigned to partitions? That depends on the partitioning strategy. Partitioning strategies are dependent on the keys of the events that are stored in them. If there’s no key, the events will be distributed among the different partitions round-robin style, so there’s no reason to expect that events that come after one another in the same partition are in cardinal order. Kafka handles events with keys by computing their destination from a hash of the key. This ensures that events with the same key end up in the same partition. So if your underlying logic is sound, say, you’re producing events that come from the same user, using their id as a key, it’s safe to assume that these events are coming into the partition in order. If you’re producing events to that partition that come from two different users, then the order would not necessarily be guaranteed. Conclusion… For Now! Did you find this helpful? Were there questions that I missed? Comment below, and let me know! I’ll be continuing this as part of a series of interview questions, so please let me know if there are other questions you’d like to see featured. If you’d like to solidify your understanding of Kafka, you can take this introductory course: Kafka101

Top Apache Kafka® Interview Questions for Juniors In 2023

I joined Google as an Interaction Designer as a new grad around 6 years ago. During this time, I’ve worked in multiple teams at Google and Meta. Along the way, I met many amazing mentors and sponsors who shared countless valuable pieces of advice with me. As my experience grew, I also mentored new-grad and junior designers around me. While specific situations may differ, there are questions that come up repeatedly. So, in this article, I want to pay it forward by sharing my thoughts on some of the frequently asked questions from junior designers. Here are the questions that I asked myself when I started my work at Google as a new grad. Question 1 I’m just glad I’m working here. Should I care about promotions? New Grad me: I had this question when I first joined Google and heard others often talk about impact and promotions. You should get rewarded for what you do. But as a new grad, don’t get stressed about promotions. Me now: Focus on doing great work, one project at a time. Promotions will come. I would even say: don’t worry about identifying growth areas yet. You don’t know where you want to grow until you’ve had enough exposure. Just keep your eyes open, observe what others are doing, focus on doing good work, and have a great time doing it. Question 2 Everyone else seems to know what they are doing. I wish I could be like them! New Grad me: I still clearly remember my first few months at Google’s Mountain View office, observing people rushing in and out of meeting rooms, holding their laptops. I thought everyone was so cool – busy and knowing exactly what they were doing! I couldn’t wait to be on top of my work and know how to do things! I’ve come to realize that no one really knows what they are doing (even directors and VPs sometimes!). Me now: People are making their best guesses and best efforts based on what they know. “Fake it until you make it” is true and works. The truth is that you will almost never get so familiar with the work that you feel like you know everything about it. What doesn’t change is that there will always be ambiguity and unknowns. But what can change is how you react to them. Focus on getting comfortable with ambiguity and the unknowns. Then you will be okay, regardless of what you are doing. Question 3 I freeze up at meetings, but it seems I need to say something to get noticed. Should I say something for the sake of it? New Grad me: For new grads specifically, I would say yes, push yourself to speak up, and get into a habit of speaking up at meetings. Me now: (For more experienced designers, I would suggest differently. Don’t speak for the sake of speaking. Prioritize efficiency and be result-focused.) For new grads, there’s so much to gain from speaking up, even if you just say that you agree with what others are saying or ask a question. Pushing yourself to speak up will also help you stay more focused. If you aim to speak up just once at every meeting, you will find it natural and easy to do it at any meeting in no time. When you get to that point, you can re-evaluate if what you are saying really adds value. Now it’s time we move on from the questions of a fresh new grad to those of a junior designer, and here they are. Question 4 I’m not a new grad anymore, I don’t want to be led or be told what to do by another designer. Junior me: It’s okay to be led. In fact, you should be grateful if you have a lead designer on the same project from whom you can learn. Me now: So you don’t need to reinvent the wheel. Observe how different designers approach things differently. Different designers have different superpowers. Learn from them, but understand you don’t need to be exactly like them to be successful. Observe how they lead so when your time comes, you could be a great lead designer for others, too. Question 5 I hate self-promotion for the sake of performance reviews. Do I have to do it? Junior me: This is a question many designers have asked me. Sometimes, designers see creating polished presentations or articles for self-promotion as a waste of their time and they are not sure if they want to do them. What you think of as “self-promotion” to others may be “knowledge sharing”. You may think what you are sharing is obvious, while others may find value in it. Me now: This is something I’ve started to realize only recently, too. To me and many others I know, it doesn’t come naturally to feel so proud of what we’ve done that we broadcast our work and thinking. But if we change our mindset from “self-promoting” to sharing knowledge with others, we can feel more comfortable doing it. You will be surprised how many people will find value in what you share with them! Sharing is also a great driver to reflect on and summarize what you’ve learned. Question 6 I deserved to be promoted this time! But it didn’t happen. I’m behind my Junior me: peers now. I remember feeling defeated, frustrated and angry about my first promotion. Most of my new-grad peers got promoted half a year before me. This feeling stayed with me for a long time even after my promotion happened. Comparison is never helpful. Everyone has their own path and pace. Me now: My first promotion was my slowest promotion yet. In hindsight, half of a year is fast and really doesn’t matter. Even years don't matter. There are so many people who change roles and industries mid-career. There are people who willingly down-level to change roles or go back to school. When fresh out of college, it’s inevitable to keep comparing yourself with new-grad peers. But as time goes by, everyone gets on their own path. Respect others’ pace and enjoy your own. There is one more thing that I feel is important to share with any junior employees who just start their career in tech. Remember an old saying: And I hope the advice I’ve given you in this article will help you get the most out of this exciting experience. “There is no destination; enjoy the journey.” Finally, there is an excellent motto at Meta, a question that any person should ask themselves once in a while, and the answer to which will inspire you to aim high and follow your dream. It goes like this: “What would you do if you were not afraid”?

UX Design: 6 Things I Want to Share with My Junior Designer Self

Automated tests can be run on multiple environments, multiple browsers, multiple devices and multiple data sets in parallel. These tests are less prone to human error than manual tests, which can help improve the accuracy and reliability of the testing process. Furthermore, they are repeatable, consistent and reliable which helps in reducing false positives and false negatives. In this article, I’ll talk about why you should be using automated tests in Selenium, JUnit5 and Gauge Framework. Increases Efficiency Automation tests can be run faster than manual tests, allowing more tests to be run in a shorter time period. This can help identify issues and bugs more quickly, saving time and resources in the long run. Automation tests can run on multiple environments, multiple browsers, multiple devices and multiple data sets in parallel which increases the overall efficiency of the testing process. import com.thoughtworks.gauge.Step
import org.openqa.selenium.By
import org.openqa.selenium.WebDriver
import org.openqa.selenium.chrome.ChromeDriver

class AutomationTest {
private lateinit var driver: WebDriver
@Step("Open the browser and navigate to the website")
fun openBrowser() {
    System.setProperty("webdriver.chrome.driver", "/path/to/chrome/driver")
    driver = ChromeDriver()
    driver.get("https://www.example.com")
}

@Step("Search for <searchTerm>")
fun search(searchTerm: String) {
    driver.findElement(By.name("q")).sendKeys(searchTerm)
    driver.findElement(By.name("btnK")).click()
}

@Step("Close the browser")
fun closeBrowser() {
    driver.quit()
  }
} This is an example of a simple test automation script written in which is using the library to interact with a web page, and the to organize and run the tests. This script opens a browser, navigates to a website, performs a search, and then closes the browser. Kotlin Selenium Gauge framework Because this test is automated, it can run faster than if it were performed manually. This is just a simple example, in a real-world use-case, you can have multiple scenarios, multiple test cases, and multiple test suites which can be automated and run in parallel, increasing the overall efficiency of the testing process. It's worth noting that, if you are working with a web application, there are other frameworks and tools that can be used in conjunction with or instead of Selenium, such as Cypress, WebDriverIO, and TestCafe, each one having its own specific features and advantages. Improves Accuracy Automated tests are less prone to human error than manual tests, which can help improve the accuracy and reliability of the testing process. Automated tests are repeatable, consistent and reliable which helps in reducing false positives and false negatives. import com.thoughtworks.gauge.Step
import org.openqa.selenium.By
import org.openqa.selenium.WebDriver
import org.openqa.selenium.chrome.ChromeDriver

class AutomationTest {
private lateinit var driver: WebDriver

@Step("Open the browser and navigate to the website")
fun openBrowser() {
    System.setProperty("webdriver.chrome.driver", "/path/to/chrome/driver")
    driver = ChromeDriver()
    driver.get("https://www.example.com")
}

@Step("Search for <searchTerm> and verify the result")
fun search(searchTerm: String) {
    driver.findElement(By.name("q")).sendKeys(searchTerm)
    driver.findElement(By.name("btnK")).click()
    val searchResult = driver.findElement(By.xpath("//div[@class='g']"))
    assert(searchResult.text.contains(searchTerm))
}

@Step("Close the browser")
fun closeBrowser() {
    driver.quit()
  }
} In this example, the script not only performs a search, but also verifies the results by asserting that the returned search results contain the search term. This helps ensure the test is accurate and will catch any issues that may occur with the search functionality. Because the script is automated, it will run the same way every time it is executed with the same inputs, ensuring the test is repeatable, consistent and reliable. This helps in reducing false positives and false negatives, which can occur with manual testing. Additionally, you can use test reporting tools like Gauge report, Allure, TestNG, JUnit, etc. to track test results, allowing you to see if a test has failed or passed. If it has failed, it will reveal the reason behind the failure, which helps in identifying issues early in the development process and prevents them from becoming more serious problems later on. 3. Enables Frequent Testing Automated tests can be run on a regular basis, such as every time code changes are made, which can help identify issues early in the development process and prevent them from becoming more serious problems later on. This aids in catching bugs early in the development cycle and helps in reducing the overall cost of fixing bugs. import com.thoughtworks.gauge.Step
import org.openqa.selenium.By
import org.openqa.selenium.WebDriver
import org.openqa.selenium.chrome.ChromeDriver
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.BeforeEach

class AutomationTest {
private lateinit var driver: WebDriver
@BeforeEach
fun openBrowser() {
    System.setProperty("webdriver.chrome.driver", "/path/to/chrome/driver")
    driver = ChromeDriver()
    driver.get("https://www.example.com")
}

@Test
fun testSearch() {
    driver.findElement(By.name("q")).sendKeys("searchTerm")
    driver.findElement(By.name("btnK")).click()
    val searchResult = driver.findElement(By.xpath("//div[@class='g']"))
    assert(searchResult.text.contains("searchTerm"))
}

@AfterEach
fun closeBrowser() {
    driver.quit()
  }
} This script uses JUnit5 framework and the annotation, which marks a method as a test method. This allows the test to be run automatically as part of a test suite. Additionally, the script uses the and annotations that marks a method to be executed before or after each test method. @Test @BeforeEach @AfterEach You can also use a CI/CD pipeline and integrate the automation test with it, allowing the tests to be run automatically as part of a build process and with each code change. This helps in ensuring that the code changes are tested and are of good quality before being deployed to the production. 4. Cost-effective Automated tests can run without human intervention, which reduces the cost of testing over time. Automated tests can be run on a regular basis and can be scheduled to run at a specific time which reduces the need for human resources. import com.thoughtworks.gauge.Step
import org.openqa.selenium.By
import org.openqa.selenium.WebDriver
import org.openqa.selenium.chrome.ChromeDriver
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.BeforeEach

class AutomationTest {
private lateinit var driver: WebDriver

@BeforeEach
fun openBrowser() {
    System.setProperty("webdriver.chrome.driver", "/path/to/chrome/driver")
    driver = ChromeDriver()
    driver.get("https://www.example.com")
}

@Test
fun testSearch() {
    driver.findElement(By.name("q")).sendKeys("searchTerm")
    driver.findElement(By.name("btnK")).click()
    val searchResult = driver.findElement(By.xpath("//div[@class='g']"))
    assert(searchResult.text.contains("searchTerm"))
}

@Test
fun testSignUp() {
    driver.findElement(By.linkText("Sign Up")).click()
    driver.findElement(By.name("username")).sendKeys("myusername")
    driver.findElement(By.name("password")).sendKeys("mypassword")
    driver.findElement(By.name("submit")).click()
    val message = driver.findElement(By.xpath("//div[@class='message']"))
    assert(message.text.contains("Welcome myusername"))
}

@AfterEach
fun closeBrowser() {
    driver.quit()
  }
} In this example, we have two test cases. The first one is for testing search functionality and the second one is for testing the sign-up functionality. By having multiple test cases in a single script, it increases the overall efficiency of the testing process, which can help reduce the overall cost of testing. Additionally, you can use test parameterization where you can run the same test case with multiple inputs and data sets. This increases overall test coverage and helps find more bugs,  reducing the overall cost of testing. Further, you can use cloud-based test environments such as SauceLabs, BrowserStack, and TestingBot, allowing you to run your tests on a variety of browsers and operating systems without having to maintain your own test infrastructure. This can reduce the costs associated with maintaining and scaling test infrastructure. Overall, automated tests can be cost-effective by reducing the need for human resources, increasing the efficiency of the testing process, and by using cloud-based test environments. 5. Increases Coverage Automated tests can cover a wide range of scenarios, inputs and use cases which are difficult to cover manually, thus increasing the overall coverage of the testing. Automated tests can cover different browsers, different devices, different versions of the operating system, different data sets and different scenarios which increases the overall coverage of the testing. import com.thoughtworks.gauge.Step
import org.openqa.selenium.By
import org.openqa.selenium.WebDriver
import org.openqa.selenium.chrome.ChromeDriver
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.CsvSource

class AutomationTest {
private lateinit var driver: WebDriver

@BeforeEach
fun openBrowser() {
    System.setProperty("webdriver.chrome.driver", "/path/to/chrome/driver")
    driver = ChromeDriver()
    driver.get("https://www.example.com")
}

@ParameterizedTest
@CsvSource(value = ["searchTerm1, expectedResult1", "searchTerm2, expectedResult2", "searchTerm3, expectedResult3"])
fun testSearch(searchTerm: String, expectedResult: String) {
    driver.findElement(By.name("q")).sendKeys(searchTerm)
    driver.findElement(By.name("btnK")).click()
    val searchResult = driver.findElement(By.xpath("//div[@class='g']"))
    assert(searchResult.text.contains(expectedResult))
}

@AfterEach
fun closeBrowser() {
    driver.quit()
  }
} In this example, we are using the JUnit5 annotation and to run the same test case with multiple inputs, increasing the overall test coverage. The test will run three times with different input values, and each time it will check if the output matches the expected result. @ParameterizedTest @CsvSource This way you can test the same functionality with multiple data sets, which helps in finding more bugs and increases the overall test coverage. Additionally, you can also use data-driven testing frameworks like TestNG, JUnit5, etc. to run the test cases with multiple inputs,  increasing the overall test coverage. Automated tests run in the same way every time, ensuring the same issues are not missed repeatedly. Automated tests are repeatable, consistent and reliable which reduces false positives and false negatives. 6. Improves Consistency import com.thoughtworks.gauge.Step
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response

class API_AutomationTest {

@Step("GET request to <endpoint> and verify the response")
fun testAPI(endpoint: String) {
    val client = OkHttpClient()
    val request = Request.Builder()
        .url(endpoint)
        .get()
        .build()
    val response = client.newCall(request).execute()
    val json = response.body()?.string()
    assert(json!!.contains("\"userId\": 1"))
  }
} This script uses the Gauge framework and the annotation, which marks a method as a step in the test scenario. This allows the test scenario to be written in a readable and understandable format, making the flow of the test easy to understand. @Step You can also use the gauge's concept of data-driven testing, where you can run the same test scenario with multiple inputs, increasing the overall test coverage and potentially finding more bugs. Additionally, you can use the gauge's reporting capability, which provides a clear and concise report of the test scenarios, test results and the test execution time. 7. Enables Continuous Integration and Continuous Delivery Automated testing is a key enabler for continuous integration and delivery, which is a critical aspect of modern software development. Automated tests can be integrated with the CI/CD pipeline and can be run automatically on every code change, ensuring the code changes are tested and are of good quality before being deployed to the production. You can use a CI/CD pipeline and integrate the script with it, allowing the tests to be run automatically as part of a build process, and with each code change. For example, you can use Jenkins, Travis, CircleCI, etc. as a CI/CD tool. Then you can set up the job to build the project, run the test cases and deploy the application to the production if the tests pass. This is a critical aspect of modern software development, and it helps in achieving a faster and more reliable software delivery. pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh './gradlew build'
            }
        }
        stage('Test') {
            steps {
                sh 'gauge run specs/'
            }
        }
        stage('Deploy') {
            steps {
                sh './deploy.sh'
            }
        }
    }
} This Jenkinsfile defines a pipeline with three stages: Build, Test and Deploy. In the , the pipeline runs the command './gradlew build'. This command will build the project and generate the necessary artifacts. Build stage In the , the pipeline runs the command 'gauge run specs/'. This command will execute all the gauge test cases in the specs folder. Test stage In the , the pipeline runs the command './deploy.sh'. This command will deploy the application to the production environment. Deploy stage You can set up the Jenkins job to run this Jenkinsfile and it will build, test and deploy the application if the tests pass. With this example, you can see how you can use the Gauge tests in a Jenkinsfile to enable continuous integration and continuous delivery. This allows you to automate the testing process. Final Thoughts Increases efficiency by allowing multiple test cases to be run in a single script. Improves accuracy by reducing human error and providing consistent results. Enables frequent testing by making it easy to run tests on a regular basis. Is cost effective by reducing the overall cost of testing and increasing test coverage. Increases coverage by allowing the same test case to be run with multiple inputs and data sets. Improves consistency by ensuring that the software is working as expected. Enables Continuous integration and Continuous delivery by allowing the tests to be run automatically as part of a build process, and with each code change, ensuring the code changes are tested and are of good quality before being deployed to the production. Overall, automation testing helps in improving the overall quality of the software, reducing the overall cost of testing, increasing the test coverage, improving consistency and enabling continuous integration and continuous delivery which results in faster and more reliable software delivery.

7 Reasons to Use Automated Tests in Selenium, JUnit5, and Gauge Framework 

7 razones para usar pruebas automatizadas en Selenium, JUnit5 y Gauge Framework

7 raisons d'utiliser des tests automatisés dans Selenium, JUnit5 et Gauge Framework

सेलेनियम, JUnit5 और गेज फ्रेमवर्क में स्वचालित परीक्षण का उपयोग करने के 7 कारण

Selenium、JUnit5、Gauge Framework で自動テストを使用する 7 つの理由

7 razões para usar testes automatizados em Selenium, JUnit5 e Gauge Framework

7 lý do nên sử dụng Kiểm thử tự động trong Selenium, JUnit5 và Gauge Framework

在 Selenium、JUnit5 和 Gauge Framework 中使用自动化测试的 7 个理由

As the clock struck midnight, five days after ChatGPT was launched and it reached 1 million users, I decided to play devil’s advocate and feed it with programming questions that I have known to be the crux of disconnect between Juniors and Seniors in the programming/coding area. The cause of that disconnect can sometimes be the Juniors' incapacity to dive into the "why," and frequently choosing an incorrect library; which leads to wrong algorithmic complexity, lack of experience, and so on. Seniors, too, are susceptible to logical myopia and may make incorrect judgments in the pursuit of "tradeoffs" that do not make sense. I used the Python language ecosystems to reveal the hallucination (i.e. seemingly real perception of something not actually present/real) of ChatGPT, which may not serve Juniors well in their decision-making and prevent them from making an informed decision by understanding the “why.” This post is not meant to disparage ChatGPT but to exhort Juniors to pay attention to what they set out to study and encourage them to not cut corners by using ChatGPT. . We’ll ask ChatGPT about a few Panda/DataFrame functions to investigate the number of rows and columns. We will footprint our ordeal on , , , , , and asking which of these functions has the fastest Algorithmic Complexity. Let’s take it a bit further and get into the spiritual game of Python df.count() df.shape[0] len(df) len(df.index) df.info() df.value_counts() It’s necessary to define “Algorithmic Complexity” with a few explanations of how we designate the efficiency of an algorithm in computer science using “Big O Notation” before we proceed to question ChatGPT: : Algorithmic Complexity Algorithmic Complexity measures how long an algorithm/function/code would take to complete given an input of size n, where “n” is data elements that can be more than one. Complexity measures how the processing time fluctuates as the problem grows in size. : Big O Notation Big O Notation is a concept borrowed from the field of Mathematics. It is used to measure the efficiency of an algorithm. When a function is said to be O(1), it means that the function runs in "constant time," regardless of how large the size is. When a function is said to be O(N), the function runs in "linear time." It is a rule of thumb to prefer O(1) to O(N) because O(N) takes more than a single step and deters the efficiency of a program. You would prefer a function/method/algorithm to take either one (1) input or seventy (70) million inputs and process it all in a nanosecond under a single step, rather than running seventy (70 )million inputs for 1 hour because it takes seventy million steps to process it. When a solution outputs badly by taking time because the number of elements (n) is much, it’s considered a bad solution. It is also necessary to note the algorithmic complexity differences may be more or less significant depending on the specific hardware and software environment you are using. So, let’s have some level of romance with ChatGPT and question the efficiency of , , , , , and : df.count() df.shape[0] len(df) len(df.index) df.info() df.value_counts() This is an absolute hallucination, and if you take it for its word, you will end up underperforming in your career path. It is wrong! We will investigate this verdict. But before that, it’s necessary to mention that enjoying ChatGPT means you have to be knowledgeable to train ChatGPT yourself and be able to frown at it when it makes the wrong decision. ChatGPT is versatile in some responses but poor in questions like checking what is better, solely because it wasn’t trained to dig into standard libraries to make the best decision. Investigation: df.count() https://github.com/pandas-dev/pandas/blob/v1.5.2/pandas/core/frame.py#L10620-L10721 This function takes multiple steps to return a value. As far as I can see, this is O(N), and ChatGPT is incorrect with its response. df.info() . https://github.com/pandas-dev/pandas/blob/v1.5.2/pandas/core/frame.py#L3433-L3461 This is also in “ e” O(N). Regardless of the input, it takes more than a single step. Even though this method takes cognizance of –a look at Line 3463 on the link to its standard library shows that. It optionally defaults index to True and elements of `object` dtype. It can’t be faster than other methods. With the memory usage of the index is the first item in the output, and that gives it some hedge; however, it still doesn’t automatically make it the most efficient algorithmic complexity. linear tim memory_usage index=True df.value_counts() https://github.com/pandas-dev/pandas/blob/v1.5.2/pandas/core/frame.py#L7104-L7228 As far as I can see, this method is O(N). It does extra steps, and one of those steps is that it forces MultiIndex for a single column. df.shape[0] https://github.com/pandas-dev/pandas/blob/v1.5.2/pandas/core/frame.py#L873-L893 This “could have been” what I will consider O(1), but unfortunately, by definition, it takes a bit longer than . By definition, it returns . So, it cant be faster than what it’s returning, and it can’t be the one with the fastest algorithmic complexity. len(df.index) , len(self.index), len(self.columns) len(df) https://docs.python.org/3/library/functions.html?highlight=len#len is a Python built-in function, allowing itself to be used with other third-party libraries such as NumPy and Panda DataFrame, hence my perception of passing in DataFrame as an argument into it. What it does is it simply returns the length of an object. len() To have some understanding of , from your IDLE run , as seen below: len() help(len) >>> help(len)
Help on built-in function len in module builtins:

len(obj, /)
    Return the number of items in a container.

>>> The built-in definition of in CPython (i.e. ) itself is not O(1); it’s an absolute O(N). In fact, Line 1679 calls on , which is another journey altogether. len() https://github.com/python/cpython/blob/main/Python/bltinmodule.c#L1683 PyObject_Size(obj); https://github.com/python/cpython/blob/main/Objects/abstract.c#L52 So, is O(N) by birth! len() We will remain on this built-in function for the next check. Apparently, we will pass in pandas.DataFrame.index, which is expected to make it faster, given that Python is written in C programming language and in turn faster than Python. len(df.index) https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.index.html is the index (row labels) of the DataFrame. So we are still discussing . I will submit that it is O(N). Why? Because this method is just building upon the function aforementioned by indexing DataFrame. df.index len() len() Indexes are faster to parse by computer systems generally. We will discuss this while we check the performance of these functions in the Benchmark section. So far, we have established the incorrect verdicts of ChatGPT and demonstrated that you must have prior knowledge to help train ChatGPT. At this point, some will ask which one is better or faster to use. Stick around! It would be interesting to remember that this is “not” to disparage ChatGPT but to exhort Juniors to pay attention to what they set out to study and not cut corners by using ChatGPT. Let’s ask ChatGPT if it is sure. Hmmm? May , and the rest of the contributors to Python & Panda be praised! ChatGPT asserts its response is sensible. It held firm on its argument, thus unjustly building a software folk who agreed with the judgment. Guido van Rossum , Wes McKinney It’s sane that it suggested we check for performance benchmarks. Let’s write a simple code to test these functions. Benchmark: import pandas as pd
import numpy as np

# DataFrame with 10,000,000 rows and 30 columns
df = pd.DataFrame(np.random.randint(0, 100, size=(10000000, 30)))

# You may include this just to remove some rows to avoid RangeIndex.
# Either ways, the most performant is still the most performant.
df = df.drop([12,14,16,18], axis='rows')

# Test Benchmark
%timeit df.count()
%timeit df.shape[0]
%timeit df.info()
%timeit len(df)
%timeit len(df.index) The output is impressive to find out and came out to the two topmost performant functions, followed by . These three(3) functions responded with a “ timeframe response report, while the rest are all in “ You may copy the code and try it yourself. Please see the attached image below; the benchmark test was conducted using Python 3.10.9 on an i5 8th gen mobile processor. len(df.index) df.shape[0] len(df) nanoseconds” milliseconds.” While the most performant is , it is understandable why. . This surely will be explained going forward. len(df.index) Computer memory parses indexes faster DataFrame objects naturally have an explicit index that you may use to refer to and change the data. Using DataFrame for the purpose of testing ChatGPT’s hallucination, we know that the columns of our DataFrame itself are an object holding the column labels. This Index object is an intriguing structure in and of itself, as it can be seen as either an immutable array or an ordered set (technically a multi-set, as Index objects may contain repeated values). Index The scale rasterized code, or streamlined version of the initial code below, will do more justice to understanding we are playing with Array with Indexes under the hood. dframe = pd.DataFrame(np.random.randint(0, 10, size=(10, 3)))
df = dframe.drop([2,4,6,8], axis='rows')

print(df)
#    0  1  2
# 0  6  3  7
# 1  4  1  7
# 3  9  9  2
# 5  1  1  5
# 7  0  4  4
# 9  9  6  1

print(df.index)
# Int64Index([0, 1, 3, 5, 7, 9], dtype='int64')

print(df.columns)
# RangeIndex(start=0, stop=3, step=1)

print(df.values)

# [[6 3 7]
#  [4 1 7]
#  [9 9 2]
#  [1 1 5]
#  [0 4 4]
#  [9 6 1]]

print(df.values.__class__)
# <class 'numpy.ndarray'> Therefore, may be conceived of as a two-dimensional NumPy array known as a matrix (a table of rows and columns). DataFrame When an array is declared, the computer system puts it in the empty/unoccupied memory location/address sequentially (following a logical order), where it can easily write the array fully no matter how large the array is, adding indexes to it, thereby picking the value easily. Pictorial representation of the reality of an Array i.e. , is as below: an_array = [“lagos”, “london”, “ottawa”, “alberta”] "lagos" "london" "ottawa" "alberta" Memory Address 3010 3011 3012 3013 Index 0 1 2 3 The "Read" ability is one of Array's four (4) data operations, and it is naturally thought to be efficient, given what I explained earlier. The others are Search, Insert, and Delete. Computers are generally capable of effectively reading arrays due to this characteristic. So far, we have established the hallucinating boldface of ChatGPT, and it is even expected of you and I to help train ChatGPT by voting down and correcting it. In summary, deciding which function to use as a software person always depends on your use cases. And in most cases, you cannot use a single function with the mindset that it has the best algorithmic complexity without figuring that out by digging deep. It’s always not one size fits all. You will have tradeoffs that will entail you using something slower than what you figured out to be faster. Libraries grow. Bugs get fixed. In fact, you will see me investigate a reported bug on Panda involving . What I figured out while investigating it is that it doesn’t allow you to supply a Class Object to function, which is not supposed to be, and it worked well for and . A fix was by the who raised it, and the issue was closed. The release of Panda v2.0.0 comes with a total fix for that problem/issue. . .DataFrameGrouBy.value_counts raising an error when used with a :class: TimeGrouper (:issue 50486) here value_counts() .count() .size() submitted contributor You will do yourself a bad service by just taking verdicts blindly from ChatGPT. Therefore, your mastery and learning processes are important. Trust the process and learn what it takes as a Dev “Bear in mind ChatGPT or any other AI out there will not replace Software Devs” Some advice I can point you to regarding how to use ChatGPT for a better response is from ’s Tweet. Some excerpts from his Tweet content are below, and I quote: Rob Lennon : Simulate an expert Ask ChatGPT to play the part of a customer, co-host, or talented expert. Have a conversation with it, or ask it to generate content as if it were that specific persona. : Challenge the conventional narrative Ask for examples of what contradicts the dominant narrative. Generate content that challenges readers' assumptions. Seek out provocative angles that defy expectations and break the mold. : Use unconventional prompts Try using prompts that are more open-ended or abstract. This way you’ll get unique and creative responses nobody else is. By getting weird, you can unlock ChatGPT's creative potential in finding vivid language and unexpected topics. : Be Ultra-Brainstormer It’s easy to have ChatGPT generate a list of potential topic ideas for your next project. But often they're generic and expected. Instead, ask it to come up with new angles or approaches to cover a familiar topic. : Capture your writing style Feed ChatGPT your writing. Ask it to help you create a style guide for future outputs. It’ll give you the exact words to describe your voice and tone in a way that AIs understand. : Have ChatGPT write from different perspectives Ask it to write from the perspective of a group of characters with different backgrounds or viewpoints. Explore new ideas and perspectives, and add depth to your writing. : Generate content with a specific purpose or goal in mind Tell ChatGPT who your audience is and what you want to achieve with your content. Remember, it has no context about who you are or what you want unless you give it some. So give it context.

The Hallucinating Boldface of ChatGPT— A Warning to Juniors in the Programming/Coding Career Path

The Noonification: How I Became a 100x Developer - As a Junior (1/3/2023)

The idea of a 10x developer, or a rockstar developer, being better than every other developer at everything, is a myth. Instead, you should strive to be a 100x developer in very specific situations, a 10x developer in some, and a 1x developer in as many as possible. It's important to be aware of the areas you excel at and the areas that you may need to work on. Unless you work for a large tech company, it's likely you'll be wearing multiple hats. On a daily basis, you'll need to be able to switch between front-end, back-end, and language-specific development, such as Java or TypeScript. This is due to the ever-changing nature of our industry and the sheer number of ways to achieve the same tasks - like printing “Hello World” in over 400 different programming languages. It's impossible to be good at everything, but it is possible to be great at something. To elaborate, I'd like to share a story from over a decade ago which was a life-changing moment that had a huge impact on my career. How I Became a 100x Developer - as a Junior I worked with a large MNC and was part of a team that was struggling to keep up with demand. They had built a custom Java web application that thousands of employees were using daily, but as the number of records going in and out of the SQL servers scaled up. Things were slowing down. They had already upgraded the SQL server to its limits and needed new solutions. An obvious one was to use memcache to cache some of the results. Unfortunately, memcache had been banned due to some security incidents in the past and the lack of HA. The managers had been trying to get approval for memcache for over a year but failed. Meanwhile, the devs fought an uphill battle as every 10% improvement was negated by double that in user growth. This is where I came in, and joined. I had no idea about their past 1 year of struggle and had been brought on board as a junior developer to help make some minor improvements to the UI, while the seniors focused on performance. However because, I was very annoyed by the slow performance of the dev server. And I had been playing with Hazelcast - a brand new Java-based server clustering and caching library. I used it as an alternative to memcache. And was able to get it running on the application, which had no special restrictions or special approval requirements, that killed all previous solutions. And had a working prototype with a demo ready within the same week. For one page in the platform, the API calls went from more than 10 seconds to under a second. It was a game-changer. The whole team jumped on board, and within a month, we had a "clustering solution which is definitely not memcache" in production. As my team manager and his boss treated everyone to a banquet, my manager said to me, that when he brought me on board as a smart kid, he had never expected me to be a 10x or 100x programmer who could solve their problems overnight. And that statement struck me hard. Because I was an imposter – nothing but a lucky imposter. The Lucky Imposter – Who Was a 0.1x Developer Technically, I was not a 1x or even a 10x developer. I knew less than my teammates, and I was learning on the job. My peers could do the front end better than me and the team knew how to optimize SQL (and taught me, thank you!). My biggest credit was that I was able to do the equivalent of “npm install miracle” and read its manual on how to configure it. In hindsight, there were many issues I had dodged by luck. Politics (which blocked memcache in the first place) Use case (we had no write contention safety, meaning if 2 edits happen in the same ms, the cache will be badly updated. Thankfully, this rarely ever happens) Stability (v1 of hazelcast crashes like crazy, thankfully the API server was designed to be deployed in HA mode, so this was an annoyance to the infra team at worst) Security (Having an open port to all data on the API server in a cluster, was a bad idea on my part, and a very junior mistake until another senior thankfully read the docs on how to secure it) Language stack (if the server was in Python, .NET, C# or Ruby, I would have no idea how to even include a local cluster cache) I was lucky to have a handful of one-trick ponies, which made me 100x in the right situations. Which were only possible because of the foundational work put in place by the rest of the team. I was also lucky that my managers and bosses allowed me to choose the problems I wanted to fix, as they fast-tracked me, and threw me across multiple teams to "fix their problems". While allowing me to maximise my luck-to-impact ratio and repeat the “miracles”. With experience, I also realised the opposite – I am slow at front-end development. This was what I was originally supposed to be doing before I was fast-tracked as a 10x engineer and it made me reflect a lot over the years. As it could have been the path I would have been stuck on. It also struck me that in hindsight, having "mastered" hazelcast, and various other technologies. How much it would have failed for other teams, even in the same organisation, were it not for the unique situation, and safeguards, which should have been credited to the rest of the team. I struck lucky, as a junior, if anything else. https://twitter.com/CenturiiC/status/1566060367825883136?embedable=true This is why Senior Developers Tend to be 10x Junior Developers Once we look beyond the generalisations of engineering, it becomes clear that everyone has their skills, which can range from 100x to 0.1x. Over the years, as I moved across many teams and projects, I eventually became a “senior” developer. During this time, I realised that seniors generally have more skills, and know what they are good and bad at. They can proactively inform their managers, and prioritise tasks accordingly. This doesn’t mean they know how to do everything, but it means they know what not to do. Juniors, on the other hand, struggle with this as they lack the experience to know what they are good at or bad at. There isn’t an easy way to find this out other than to just “try”. Once this is understood, it becomes apparent that it’s all about maximising the number of things you know you can do reliably and well. It’s also about maximising your luck factor when it comes to being assigned tasks, and ensuring you’re not stuck with things you’re bad at. In a way for juniors, their progress will depend heavily on the alignment of their luck and skillset. Seniors, had more (but not full) control, over how to steer their progress. In this case: Luck isn’t binary. You can increase the number of situations that align with you. How to Maximise Your Situation Luck at 100x and 10x For everyone, but especially for juniors and those just starting out, the best thing to do is to keep trying new things in technology and exploring. This will help you figure out what you’re good at and what you’re bad at. For those who have a better idea of what they are good at, the next step is to expand the number of situations where they can perform their best. This involves some practice and research into adjacent technologies to the ones they already know. Once you become great at something, make sure to own it so your managers and bosses know that this is what they should give you. This will increase the chances of hitting those 10x or 100x situations more frequently. Find at least one thing you’re good at, even if it’s a very small and narrow thing. Build up from there. (Some notable examples include regex and configuring webpack.) For seniors, if you haven’t done so already, start looking beyond the technical aspects of development. This doesn’t mean you have to move into management. But with your unique technical knowledge, you can play a more active role in understanding the user or business use case. This will allow you to optimize with your managers to ensure 10x or 100x success rates for you and your team. For those who are job hunting, if you know you’re good at something, even if it’s 10x, do some research and dig deeper into your job hunt. Try to find a well-funded startup or MNC that is facing difficulty in the exact thing you’re good at. While this can be difficult to pull off and does involve some networking, if you place yourself in the right place and time, it will maximize the impact for both you and the company involved. These are all things, you can do slowly over time, to improve the luck factor. And deliver that 10x experience more consistently. Special shout out to read article on how to create luck: swyx swyx.io/create-luck As a CTO and Team Leader Today, This Still Holds - 10x Is a Myth - Everyone Is Both 100x and 0.1x Some may think that the CTO of a UI testing tool such as would be good with front-end technologies. However, this is far from the truth. Our average fresh hire or junior in the company is typically faster than me the CTO when it comes to writing front-end components with modern front-end frameworks such as Vue.js or React. Uilicious.com This has changed my perspective as a team leader/manager. It showed me how toxic and bad the 10x engineer myth is. It’s an oversimplification of labels and generalization of very unique situations. It’s a toxic misconception that needs to be fixed. Almost every startup 10x engineer myth, when looked into deeper, turns out to have an individual with unique knowledge in the right place and time. And was able to avoid the tasks they were 0.1x at. In my case, it was focusing on infrastructure over front-end development. Where instead, I have other team members who are 1000x times better at doing frontend development. This is an important realization as a manager because, for every individual who is 100x at one task, there’s a task that makes them 0.1x as they get stuck in a time sink. It’s about understanding and recognizing what each individual is 100x at, and what they’re 0.1x at. While this sounds very straightforward, this is significantly harder in practice. There are many things a team leader or developer will not know till they have tried it before. Or are given the time and opportunity, to hone and master the skillsets involved in those specific situations. There are also many things, especially new technologies, that no one is good at it, and is all about taking risks and a chances. It’s the team leader’s job to organize tasks accordingly to best suit everyone’s needs. And if that is not possible, it's also about understanding that even if someone can’t be 100x in your situation now, they can potentially be elsewhere in other teams. And is on every individual developer, to figure out what they are good and bad at, and to communicate that to their team accordingly. So to death with the 10x Engineer Myth, Long live the 100x Engineer in specific situations PS: If you have not made any new year's resolutions. Perhaps increasing your luck surface area could be it! ~ 🖖 live long and prosper Eugene Cheah: CTO of uilicious.com Originally posted on: https://substack.tech-talk-cto.com/p/dev-to-cto-how-do-i-become-a-10x Image credits Austin Neill - rockstar image: unsplash.com/photos/sxxnM-tRlVg XKCD - comic on standards: xkcd.com/927 CenturiiC - Comic on experienced engineers: twitter.com/CenturiiC/status/15660603678258.. Lucas Santos - Dice picture: unsplash.com/photos/XIIsv6AshJY Vlad Hilitanu - Lego figs: unsplash.com/photos/1FI2QAYPa-Y

Stories, News & Mentions about JUNI

Juni’s Stories on HackerNoon