Apprenticeship pattern: Expose your ignorance

I was reading chapter two on “Expose your ignorance” and got so caught up to it. When working with my team this semester, if there is something that I learned is to ask questions and not be afraid to show my “ignorance” like the book calls it. Sharing and exposing myself helped me understand that we should never feel less smarter than others just because they know better than we do, because learning and knowledge is open to everybody and it is not impossible to reach their level or even better, surpass them.

It can always happen to be caught up in the middle of a project that we do not know anything about. Some people might, and some might not. In that situation, we should let our ignorance awaken our curiosity so we can easily ask questions. People in general hate being seen as ignorant because we always want to show that we have knowledge, experience, skills required for the position or project. So, because of that, we find ourselves faking our knowledge and skills just to impress others. But software development does not work like this, it’s either we know or we don.t because the more we try to hide our ignorance, the more we’re sinking ourselves; And there will be a moment when it will be hard to get out of that place we got stuck on our own.

I love what the author said about the runner: ” She’s not training to have strong legs; she’s training to run. Like the motivated developer who after working on a Python for two years achieves a deep knowledge of Python, the marathon runner’s strong leg muscles are a means, not an end”. Craftsmen need to have the courage and humility to set aside their expertise and wear the “white belt” as they pick up an unfamiliar technology or learn a new domain.

One of the most important traits that a craftsman can possess is the ability to learn, identifying an area of ignorance and working to reduce it. As, software developers, we should not run away from knowledge and being shy or scared to expose our ignorance is not doing anything god to us. I am proud of asking questions and showing that I don’t have or I barely do have knowledge about a certain domain. And it is something that I do even with my team. When I am not familiar with something or don’t know how to do it, I just ask and the one that have the answer will provide it to me and help me understand. This is how I increase my knowledge and skills.

This is where “The long road” will take place. By exposing our ignorance, and then confront it. We will spin the missing threads much more quickly than we will by faking it in order to appear competent. And let’s remember that while we are exposing our ignorance, we are also exposing our team to our learning ability.

From the blog CS@Worcester – Gracia's Blog (Computer Science Major) by gkitenge and used with permission of the author. All other rights reserved by the author.

Be the Worst

When reading this chapter, I found it challenging because I asked myself who actually wants to be the worst? I tried to project myself and put myself in that specific position and I found it very hard to do. However, after second thoughts, deep reading, and analysis, I am very impressed and humbled by the content of this book and this chapter. They say: “You have to be the best”, “You have to master what you do”, “You have to always be the head”. However, we never hear the opposite of those sentences. We never hear: “Be the worst”, “It’s okay to start at the end of the queue”, “We all started from the bottom”. It is discouraging to know that nowadays when working as an apprentice, the expectation and the pressure is greater than the willingness to be understanding and people tend to forget that they have been there once and act as if they were the best from the start.

 There are points the author mentioned that I found important when being the worst in a team. He talks about couple of risks associated with it like brining the team down, the risk of getting fired when falling behind or inability to catch up and feel bad about ourselves. This part tells us that it is a great thing to accept being the tail of a lion. However, it comes with some risks that require hard work and regularly updating ourselves on where am I? Am I making progress? How much time the team is granting me and what happens if I don’t meet specifications? Being the worst is just a way to make us confident in the lion’s den, but we must really be motivated to learn, we must show the desire of doing better, bringing ideas that get us noticed with time.

The last interesting point the author mentioned was reaching out, asking to join a team and observe the team’s dynamics and ways of operation. For me, this is great because it shows the desire for personal growth and the team might be motivated to take you in because you have shown initiative and interest. I feel more confident now to “Be the Worst” in a team of professional software developers because that position will unleash my confidence, allow me to be myself, learn and improve at the same time in my craftsman’s journey.

From the blog CS@Worcester – Software Intellect by rkitenge91 and used with permission of the author. All other rights reserved by the author.

Apprenticeship Patterns Post #3

“Craft over Art” was a great apprenticeship pattern to read about and I found myself relating to the ideas with my own work. A craft is an art that has functionality – a painting you can look at and hang on the wall, but a table or couch provides you with functionality. Good software should be written so it looks good and performs is purpose.

When constructing a piece of software it’s important to look at the tools we are going to use. A programming language, a laptop or PC, a good IDE, Unit Tests, and an outline of what the system should look like. No one starts a craft such as furniture building by grabbing a piece of wood and one by one assembling the project. They first create a blueprint with measurements, a model, and gather all necessary materials before they begin following their blueprint. I enjoy this analogy because I’ve made this mistake in the past when writing code. I would usually go line by line and fix mistakes one by one as I find them. This way of writing code is quite slow and it can be easy to drop a project because it seems too large or difficult. Now I follow a plan when I write my code and even if a method I’m working on has issues, I’ll move on to the next method. I’ll also create my methods before hand and leave them empty until I begin working on one to ensure I’m still following the system I designed for the project.

Art is also an important factor of crafting. If my code is messy, unorganized, and does not have good flow it will be incredibly difficult to refactor the code later on. When we enter the workforce it’s unlikely we will be writing a piece of software completely on our own. Your code will be combined with dozens and hundreds of other programmers work and it’s important that the system works well together.

From the blog CS@Worcester – Site Title by lenagviaz and used with permission of the author. All other rights reserved by the author.

Apprenticeship Patterns Post #2

This week I really enjoyed reading “The Long Road” from the apprenticeship patterns. In computer science, often many of us feel like we need to learn as much as we can in the four years we are getting our degree and then go out and apply that in a full time position. The reality is that we only learn the basics in our undergraduate degree – enough to gain strong logic and critical thinking skills and enough to get that first job. The real learning comes from actually working as a software developer and there is no “end” to how much you can learn in software engineering.

The tech industry is constantly evolving and every two years it seems like there is a shift in how technologies are used or new technologies are introduced. A software engineer cannot stop learning once they have learned everything it takes to perform their programming job well. Skills they learn in that job will always carry over, however they may end up working with completely different or newer frameworks and they have to start the process of learning again. That’s why as software engineers we should have the mindset of “always learning” rather than “learning something new when needed to”.

From the blog CS@Worcester – Site Title by lenagviaz and used with permission of the author. All other rights reserved by the author.

Sweep the Floor

I had the opportunity to participate in a formal summer program to learn how to make simple websites. When I was twenty-two years old, I was hired and brought me back every summer and winter vacation during college. I didn’t know anything about how to make a website when I started my first project. For fun, I wrote some code to make small programs and scripts. There were few places where I could add value to the company’s operations when I first started my website for that program. I couldn’t build a website, and I couldn’t possibly teach people how to do so.

Many of the successful Programming leaders were hired by the company to teach a PHP course at the time. Since I was not good enough, I decided to start working on other tasks. I’d also set up the computers, install the appropriate software for the exercises, and clean up the space. These duties helped me gain confidence in my ability to contribute to the team and the firm. Even though I was having difficulty learning to code, I was still able to contribute with specialized talents and duties that required less competence.

As I was continuing working on the program, I was gradually given more technically difficult jobs. They were, however, frequently the ones you’d allocate to the lowest man on the totem pole. Moving servers, setting out backup methods, and updating material on the website are all tasks that need to be completed. These assignments allowed me to achieve little triumphs at a time when it was difficult to achieve them by creating code.
Playing the part of a typical program taught me humility and respect for experienced trainees. I decided to choose to sweep the flooring partner because it resonates with everything in my previous job experience.

It’s true when Paul Pagel described young apprentice like One of the pillars of a successful apprenticeship is humility. Humility, when combined with ambition, will keep you focused and moving in the right route. You risk prematurely declaring your apprenticeship complete and missing out on critical lessons if you don’t have them. Perhaps you’re pleased with a large project or subsystem you’ve completed and believe it demonstrates that you’ve progressed to the level of journeyman. Perhaps. Have you, on the other hand, delivered something important across several platforms? How much more would you learn if you attempted to learn a new language? The natural tendency of any ambitious apprentice is to attempt to beat the clock and become a journeyman as soon as feasible.

From the blog CS@Worcester – Site Title by proctech21 and used with permission of the author. All other rights reserved by the author.

Learn How You Fail

According to Atul Gawande, Software is not a product, it’s a medium for storing knowledge. Therefore, software development is not a product-producing activity, it is a knowledge acquiring activity. Knowledge is just the other side of the coin of ignorance, therefore software development is an ignorance-reduction activity.

The value of failure-based learning is undeniable. Organizations that excel at it, however, are extremely rare. This disparity is not due to a lack of desire to study. Managers in the vast majority of the companies such as pharmaceutical, financial services, product design, telecommunications, and construction firms; hospitals; and NASA’s space shuttle program, to name a few—were genuinely interested in helping their companies learn from failures and improve future performance. They and their teams had spent many hours on after-action evaluations, postmortems, and other similar activities in certain circumstances. But, time after time, we noticed that arduous efforts yielded no tangible results. The reason for this is that those managers were approaching failure incorrectly. 

As a former manager myself, I always thought about what my boss would say if I did not meet all the requirements left out for me to accomplish in a tiny window. I overstress myself to succeed, and by trying too hard, I kept getting crashed over and over until I realized that was not the best approach. I never got the results that I was looking for with that mindset. Failure is hard to accept because we usually associate it with a negative aspect instead using it to learn and produce success for tomorrow. As I was told if you never fail, you don’t know what success is. 

As Phillip Armour, in his paper “The Five Orders of Ignorance,” As I paraphrase it; Continuous learning can either be a blessing or a curse. Learning a new skill may be excruciating, especially when done under duress and with no supervision. However, the software developer, like the athlete who must deal with bodily fatigue after intense workouts, must deal with the mental dissonance that comes with learning something new. That discord might be viewed as a positive indicator of growth. On the surface, self-reflection, detecting failure through feedback loops, and discovering your deficiencies all appear unpleasant, yet these patterns are helping you lessen your ignorance. The alternative is to concentrate solely on what you already know, but this is not the path to mastering software craftsmanship; rather, it is the path to specializing in a single field. 

From the blog CS@Worcester – Site Title by proctech21 and used with permission of the author. All other rights reserved by the author.

Sprint 1 Retrospective

For Sprint 1, I mainly worked on the frontend of the guest info system. In our group, we split our team into two teams, one for the backend, one for the frontend. This is how we operated until the end of the sprint. We found that this way of splitting the work between the two groups worked well. I don’t think there were any issues with how this worked. I think my only criticism would be that I wouldn’t know what the backend was doing but that was mostly due to us only now starting with stand up meetings. Also, could be due to the fact that we mainly communicated between our own groups. This is a issue I think we could fix, I also need to work on my communication skills more because I sometimes find myself lost at times with what we’re doing.

Another thing that worked well was how well we adjusted to Scrum. I think our Scrum master, Vien, was a really good leader and was the leading factor as to why we did well with this framework. He helped set up everything for us and set the structure for how our team should work and what we should do. He was also very helpful and considerate with me when I would be stuck on something or one of us had an error with something, he would try to figure out what the issue was.

This sprint, I think I could’ve done a lot more, although the work for the frontend was kind of scarce and were minor fixes. For the frontend, we just needed to refactor mostly in this sprint and format it in CSS. CSS seemed the hardest and I wanted to work on it with another team member but he ended up formatting it all alone so I ended up not being able to work on it. Again, this was a communication issue from me since I didn’t tell him I wanted to work on it collaboratively. He ended up doing a great job on the CSS formatting, it almost looked like what we wanted it to look like, a Google Forms page.

As for me, I definitely could’ve done more. The amount of work I did compared to my other frontend team members is definitely lacking and you can see it in the commits. I’m also definitely the weakest coder in the group and it’s very evident. I am trying to learn more and more as I go through the sprint and being in this group encourages me to learn more and become better. In this next sprint, I’m gonna try to do more work, maybe even some of the harder issues like integration and deployment. On a more positive note, I think the group I’m in is a great group of people and is motivating me to be a better coder because this would be similar to the type of work I would be doing when I go into a software dev job.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfofrontend/-/commit/cff5f606ea5df652e8e501c65e4166fb26401235
Here, I merged a branch to refactor the register form template into the main branch.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfofrontend/-/commit/e5c2de68f4566e2af0796095c46199b32ca55c1f
A small change to change the id-input into vue.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfofrontend/-/commit/97c14005f3c0198c412a9f680bb7309ac442d806
Here, I moved id-input.vue from main into our refactor branch, keeping most of the code.

From the blog CS@Worcester – Brendan Lai by Brendan Lai and used with permission of the author. All other rights reserved by the author.

The Deep End

Chapter Two’s is themed around growing your knowledge. The pattern “Confront Your Ignorance” follows this theme and focuses on working with projects that are outside of your expertise. When you feel as if each project you are working on is like the previous one, it means you are applying your existing knowledge. There is truly little chance to grow as a developer when you work strictly within the areas you are knowledgeable about. The ideal scenario is one where you are working outside of your area of expertise to maximize the amount of new experience you engage with.

In the future, I will be more willing to work on projects where I dive into a topic that I do not fully understand. I also feel that the action for this pattern, to map your projects in a timeline, is a useful way to track your personal development over time. A timeline is a terrific way to see if your learning has stagnated and it is time to jump into something new. This method is also a great way to see where you want to take your professional career and give you an opportunity to map into the future.

I found it interesting how large of a risk the author suggests taking regarding a project outside of your knowledge. It is suggested to work on projects where the possibility of failure to complete them is high. In a private setting, I would gladly challenge myself by deep-diving into a project that I do not feel confident I can complete. In a professional setting, I personally am a bit too risk-averse to immediately want to take on a task where the chance of failure is greater than my chance of success. However, I appreciate that it is a gamble where if I do succeed it will boost my portfolio and whether I succeed or fail I will walk away with more knowledge than I started with. I believe it is human nature to be frightened of failure. This pattern is a great reminder that the journey that led to failure was along the way a great learning experience and the following attempt will be a success based on what you had learned.

From the blog CS@Worcester – Jared's Development Blog by Jared Moore and used with permission of the author. All other rights reserved by the author.

Week 7: Be The Worst

For this week’s pattern, I chose ‘Be the Worst’ from Chapter 4. I initially chose it because it caught my eye and I was going in order of chapters with the patterns I chose. I thought it would describe in detail to be the worst of your team but it was actually the opposite. The context is after unleashing your enthusiasm, which I assume was a pattern before this one, you take every opportunity to learn new skills. As a result, you outgrow your team and possibly your entire development organization. This was much different from what I originally thought this would be about, I thought this would be to think yourself as the worst to get better as a software craftsman. It kind of follows that pattern of thinking though, basically surrounding yourself with better developers. This in turn, will motivate you to be a better developer and have room to grow as a developer. I thought this was an interesting point, I mean this is something that I sometimes think about and is actually something I’m experiencing right now. I’m in a team that I feel like are all better developers than me which in turn makes me want to be a better developer because sometimes I feel so lost when in team discussions. This pattern really stuck with me because I related to it a lot. I just need to find the motivation to be a better developer, I need an extra push because just a team of strong developers won’t push me hard enough to find that drive to be better than I was yesterday. The pattern also mentions Breakable Toys and Reflecting as You Work as patterns to go back to because they are particularly important if you are the worst on your team, which I am. I guess I’m gonna check those out after this pattern, maybe even write about them. Honestly though, I feel like this pattern kind of reinforces impostor syndrome, which I found out is pretty common amongst developers and probably is common in STEM related jobs, but at least with this book, it puts out a solution for you to follow.

From the blog CS@Worcester – Brendan Lai by Brendan Lai and used with permission of the author. All other rights reserved by the author.

Use the Source: Blog # 5

This pattern explains the benefits of reading real world source code. If you are on an assignment and are asked to write a small component for the project, your most important task should be to read through the code-base and understand as much of the source code as possible, given the time constraints you are under. It is important for you to understand the intent of the application at a high level before studying the code, but then to immerse yourself in how the code works, how it is structured, what design patterns are used, how the class hierarchy work, and which developers were involved in the project. In most cases, it would be a mistake to try to learn all the project’s code, unless it were quite small. Consider understanding the code involved most closely to your intended assignment with the most priority. Most projects you will encounter are medium to large scale applications, and some would take you months to adequately understand.

Try meeting with the developer who wrote code most similar to what you are being assigned , and ask for tips and tricks on methods they used to build their pieces.

If you are asked to write, for example, an android activity that calls REST API’s, look for related YouTube videos, Google documentation, related code on GitLab or GitHub, textbooks, stackoverflow.com posts, and college library references, but most importantly, look directly at the code-base you are working with to find if similar code has been written which can be cloned, modified, and sometimes improved. I have worked on projects where the same basic code had been written more than once! Refactoring an application to remove repeated code, or to consolidated similar code is a huge time saver. There is nothing like management giving you a month to write something, and you come back in two days with it done. This is the type of “magic” you can accomplish if you are observant of the resources that already exist in your project, and the Open-Source world in general.

I also think it is important to read through code you have previously written. If you have resume entries stating you know a particular language or technology, a more than rudimentary understanding of it is really important for your next review or interview. As your career develops, the list of these items will increase, and some will become somewhat obsolete, so it is much more important to understand the most recent skills best. If you can’t recite a paragraph or two on any given entry, I would consider removing it from your resume.

From the blog cs@worcester – (Twinstar Blogland) by Joe Barry and used with permission of the author. All other rights reserved by the author.