独家优惠奖金 100% 高达 1 BTC + 180 免费旋转

Oh my goodness

Onsite week one

This week has been nerve wracking and thrilling and encouraging and I swear I can literally feel my brain changing. So much happened around me and inside me and it’s great, and I want to keep taking part and diving in and practicing being present and aware of all this.

Defining goals: SMART method

Delineating our goals seems to be a central practice in self directed learning, keeping us problem-focused rather than subject-focused, so here are the steps to doing that:

Specific: What exactly do I want to achieve?

Measurable: How will I know when I have achieved this?

Attainable: Can I afford the costs required to achieve this?

Relevant: Why do I want to achieve this?

Time bound: When will I achieve this?

Defining learning steps: Bloom taxonomy

Remember > Explain > Apply > Analyse > Evaluate > Create

These steps are usually shown as a pyramid to illustrate how they build on top of the previous, but I’ve just written them from top to bottom:

Test Driven Development

Why we test: to find bugs, to write documentation

Why we do TDD: to describe our user’s needs in detail (according to client) and keep a scope of development in balance with resources; to reach the MVP by writing only the code we need; to write better code (it’s good practice but not completely adopted by the coding community); it provides a structure to development; it makes sure the program does what we need it to.

Describe TDD as a set of steps: 1. User needs > 2. user story > 3. extract nouns and verbs/ objects and methods/ behaviours> 4. functional representation > 5. IRB check if works — if it works, back to (1), if it doesn’t > 6. identify input/output to define failing test > 7. run test > 8.read errors > 9. change code to make it pass > 10. run test — if it fails, back to (8), if it passes > 11. commit, back to (1)

Pair Programming

There are two main styles we have been introduced to : driver and navigator, and ping pong.

The first works by the driver handling the computer (typing, searching, etc) and the navigator giving instruction (suggesting what to make next, pointing out errors, etc), but making sure both partners are aware of why they are doing what they are, and regularly changing roles. The second works during test driven development, with someone changing the program to pass a test and then writing the next test that needs to be passed, and then switch and repeat.

There is an emphasis on feedback and iterative learning reflection on this course, and pairing is no exception, so:

Francesca: First day so some nerves in play, eager to do well with an unfamiliar activity and also make a good first impression. Discussed and established a structure (driver/navigator,25 mins, 5 min breaks) and stuck to it which worked well, but neglected good debugging practice. Reviewed our approach during the session a little but it was hard to have perspective on day one so we got stuck.

From Francesca:

Feedback for TDD 1/5/19

What worked:

- First pairing buddy! We stuck to the driver/navigator pairing technique in 25 min bursts with a five-minute break. This worked well because we both had equal time typing and discussing what we thought should happen next. Neither of us rushed ahead without the other person and we both discussed / googled what to do if we were stuck.

What could be improved:

- To take more time to read the challenge resources instead of diving right in. But you know, it was the first time so we can be excused.

- The second half of day was harder as we were(are) getting to grips with RSpec and had confusion over the folder setup. For next time we should have or create a short debugging process to refer to as it got to the point where we didn’t know what to do anymore other than start again. Regardless, we tried a lot of things and for a first pairing session I thought it we smashed it. Would pair again.

Michael: Smoother sailing today with no difficult road blocks. We started in driver/ navigator style and then switched to ping pong when we had a few unit tests to do, and then later had a less structured approach that we didn’t really discuss. Didn’t do any feedback.

Ray: Lots of seamless progress today, we followed a loose driver/navigator format but a well-defined TDD process, followed the instructions closely and adapted our approach to a chapter when necessary. To improve, could maybe include more note taking or IRB test detail in the README.

Lisa: We progressed well through the challenges, and Lisa was happy to start from my repo which was slightly behind hers (she said she’d like to understand it a bit better so going over it would be useful). We swapped regularly and took breaks based on when we felt we needed to rather than sticking just to the timer. On evaluation I thought I maybe directed our code a bit too much, at my pace, rather than giving Lisa enough time or prompts to make sure we were clear with the same things.

From Lisa:

Working together yesterday was very productive, we swapped regularly, there was good communication and I think my code in the weekend challenge will be better after pairing with you. Maybe take a little more time to explain things if your partner seems lost.

Debugging

Basic OOP principles

The Single Responsibility Principle is used to help developers write maintainable code. It means that each method or class should only be responsible for one part of a program, and if that is true then it will only have only one reason to be re-written.

Encapsulation seems closely related to SRP. It refers to keeping data within a class and only letting them access it directly. Other classes would have to call accessor methods that belong to the class with the data if they want the data to be shown or set.

These are both fundamentals that belong to SOLID, which is something I’m sure we’ll be studying soon or I will be reading about and practicing on my own.

Repo sharing on Github

Co-authoring:

This is done when pairing to credit both people and have commits included in their profile stats.

Forking, upstream and merging:

Remotes can have an origin and an upstream, which can be changed. So if I am working on someone else’s repo today and we get ahead of mine, I can change the upstream on mine to their repo and merge the changes into mine locally, so we are at the same place.

This can then be pushed to my own repo. Unless I’m wrong and you can’t merge projects that aren’t forks.

Update: Ok so following testing, this doesn’t work:

Instead, I’ll just delete my Github repo and fork theirs. Commits to a deleted project are deleted too, but I don’t think that really matters right now. If I really wanted to I suppose I could move projects into an archive repository on Github.

Curly Braces vs Parentheses in RSpec:

When checking that an error is being raised, if it is just in parenthesis, the error will occur and stop the execution of the program. To stop that happening we use curly braces to make the exception into a proc that is passed to the expect method. Parenthesis just evaluate the argument before anything else has a chance to happen, while curly braces tell the method to examine the code block and its result.

Markdown

Markdown is a language and filetype (.md) used to format writing (typically online) without the need for a word processor. It is useful for making readme files more legible, and so far I’m just using

Summary

This is a short course so I don’t expect the pace to let up, and I can see the importance of the holistic approach. I want to stay healthy and make the most of it so I’ll keep attending meditation and yoga, and use the weekends to study, repair, relax, and reinforce the healthy habits in my own space.

Add a comment

What is your view?

Send

Related posts:

Nuvem nos tempos atuais

Eu era uma menina quando ouvia esta música na voz de Gilliard. Tenho esta mania de associar palavras com letras de músicas. Atualmente esta música não sai da minha cabeça um dia sequer. Resolvi então…

The Evolution of Procurement in the Digital Era

Procurement and supply chain management is growing in corporate prominence year after year. An aspect of corporations that started off as just another responsibility of the administrative department…