Posts on The Intuitive Programmer

The Architecture of new Angular projects

Tue, 12 Apr 2022 09:33:42 -0500

Sometimes you build to learn…and that means to fail

I’ve stated earlier that personal projects are the gateway towards developing one’s confidence in an endeavor. I’m working on a habit tracker, to keep track of my habits and eventually to provide me feedback on how I am doing and building towards my own goals.

Let your creativity wander

Sometimes in thinking through a software project, I get caught up in the details. Things like, how am I going to have the list refresh after adding a new product. Am I making the right initial decisions. I’ve found solace in breaking that thought pattern. Engaging with visual diagrams has been a helpful way to help me navigate the process. Being open to the process of design allows a lot more flexibility to what it is that you engineer.

Below are some of my simple proof of concepts that cover what I wanted most out of my habit tracker. A list of high level habits that I want to accomplish and a view that shows me the days that I’ve accomplished those habits on a calendar.

Habit Library Main Page

Detail view of completed habits

Just the beginning

There’s a point in any new product where the excitment is overriden by the work. In fact, getting this prepared I was stuck on a specific issue around setting up my login page that took days to resolve. That’s okay. It’s important to develop a muscle of persistence in the face of the seemingly unimportant details. The truth of the matter is that, the details are super important. It’s often easy to fantasize about an outcome that you want but what’s in the space between is the work and you can work to avoid the work (think about it) or you can see the work as something that is to be gotten through. If you’re not feeling that sense of cutting through something then it might be a time to take a look at how you would like to spend your energy. It might be software engineering but perhaps in a different novel way?

Work, Reflect, Relax and Repeat.

Cheers,

Test Driven Development: Angular Reactive Forms

Mon, 14 Mar 2022 09:33:42 -0500

Reactive forms: Learning by doing

I’ve been developing using Angular for over a year. One thing that I love about working with the framework is how logical it can appear. To the lay programmer, it might be overly rigorous and lacking in the flexibility that other development tools might have (think React). To me, I love the rigor that comes in understanding it because it does provide a stable productive working environment in my opinion.

Mapping your entity to your form

Once you have an idea of what it is you are wanting to build, doing so in Angular with the right pattern is trivial! Take for example this coffee form example below. We initialize a form group.

orderForm: FormGroup = new FormGroup({});

Then we set the fields appropriately. Not that we can set if a field is required as well as set the default value of the field programmatically.

ngOnInit(): void {
    this.orderForm = this.fb.group({
      // this maps to the name input field...the validator required denotes
      // that it is a required field!
      name: ['', Validators.required],
      // we set email to a blank field
      email: [''],
      // we set the default selection of item to the Coffee value
      item: ['Coffee', Validators.required],
      // we set the size of the order form to default to Small
      size: ['Small',Validators.required],
      // we set the notes to be blank
      notes: ['']
    })
}

The last part is to set the formControlNames appropriately on the template file. Notice how similar the form control names are to the actual input fields!

<input
        id="name-field"
        required
        formControlName="name"
        type="text"
        name="field1" class="field-divided">

Rinse and repeat

Developing intuition is a process that takes time. Angular does a great job of providing predictable patterns that can be intuited on when working with business logic of a varying nature. Here we can see how the OrderForm might be an entity that is stored on the back end and how it can easily be extended to expand on or enhance the functionality of the application.

Check out this repo to see a basic test set up for validating the prescence of the field and inputs. Try to expand on it!

https://github.com/developer-alvin-muniz/tdd-reactive-form

Cheers,

Developing Intuition: Enjoying what you do as a beginner.

Thu, 10 Mar 2022 09:33:42 -0500

Programming is hard

Making a career out of it is even harder. But, is this the equivalent of saying that being a lawyer is hard, or even running a small business? The point is, that this life is hard. For career switchers, becoming a software engineer might seem like a fast track to life in the easy lane. Good pay, and relatively high demand for the skill set makes software engineering a hot commodity. At record rates, people are coming into the profession and loving the allure of such a career. The question becomes, how long does this last.

So you have the job…

The thing is, once you get the job, things only get more difficult. Now there are benchmarks from which you derive a certain output. Those benchmarks might be reasonable or they might be astronomically out of your league. It might be difficult to focus on what to learn because, as professionals of a sought after skill, we are constantly being exposed to the latest and greatest piece of technology. This is a choose your own adventure game. Finding some aspect of joy in it is important. In life we are constantly faced with having to make a choice and it’s often the truth that, if we side with a feeling that resides in our body and heart, we would likely be prone to having the kind of career we want. Objects of the mind are just that and fickle. Ask yourself these questions, ask for support and guide your evolution in a way that’s unique to your qualifications.

Iterate through your good ideas

Where most people loose sight of enjoyment is where they loose sight of themselves. Day after day, year after year, we are being validated by expanding on the vision of others. I’m proposing that less time be spent iterating through the dreams of others and more time spent in your world crafting, creating and communicating.

Cheers,

Test Driven Development: A lesson in failing first

Mon, 07 Mar 2022 09:33:42 -0500

Function under test

Let’s say we have a function that returns 3 names in a list.

public List<String> listOfNames(){
    return Arrays.asList("John","Jerry","Joseph");
}

To test it, we might write a test like the below.

@Test
@DisplayName("should return a list of names")
public void shouldReturnAListOfNames(){
    List<String> expected=Arrays.asList("John","Jerry","Joseph");
    List<String> actualList=postService.listOfNames();
    assertThat(expected.equals(actualList));
}

Great, your test most likely passed, but is this a good test? Trying modifying a name in the list so that the test reflects the below and run it.

@Test
@DisplayName("should return a list of names")
public void shouldReturnAListOfNames() {
    List <String> expected = Arrays.asList("John", "Jerri","Joseph"); 
    List <String> actualList = postService.listOfNames(); 
    assertThat(expected.equals(actualList));
}

This test also passed. Testing apis have a slew of different methods that serve to provide a more fluent way of writing readable tests. Not only is readability the key, they also serve developers but asserting in a proper manner.

@Test
@DisplayName("should return a list of names")
public void shouldReturnAListOfNames() {
    List <String> expected = Arrays.asList("John", "Jerri","Joseph"); 
    List <String> actualList = postService.listOfNames(); 
    assertEquals(expected,actualList); }

Now your test will fail.

Fail first approach

Test driven development emphasized that the process of a test shows that it fails first before going green. The benefit of such a test is that we are making an assertion that we do not have false positives which can lead to sneaky bugs in our production. True story.

It behoves an aspiring programmer to think of testing as a language. Thinking of your test in terms of Given, When and Then is helpful. Testing is hard, and I believe it’s made that much harder because of such sneaky scenarios. Test wisely friends!

Cheers,

1% more over time

Mon, 28 Feb 2022 09:33:42 -0500

The math is there, with sustained effort, results become apparent. I’m using this blog to serve as a measure of my knowledge in java development. I’m hoping that at some point this might help others on their journey. Today, during a pairing session, I had forgotten how to kill the process that is on a certain port. It was kind of agitating but it served as a reminder that we should invite such an experience to be something of good use, something that will serve to increase your understanding of a specific domain of choice given that you are deliberate about it. Killing the process on port :8080

lsof -i :8080

this will print out the PID which you will then proceed to kill

kill -9 PID

This might feel awkward if you haven’t done this stuff before, but worry not, developing an understanding of what the port is and why you need to kill it is important and an early lesson that benefits even experienced developers to revisit. This is a quick and simple one for today and remember, as long as you do 1% of concentrated effort, you’ll see the results in the long run.

Cheers,

Debug early and debug often

Sun, 20 Feb 2022 09:33:42 -0500

As a new software developer, it is your responsibility to understand the product that you are developing for and ask questions in instances where you do not know the answer. Having spent the better part of my career in marketing and graphic design, I’ve developed an astute ability to listen and ask good questions. While developing a technological understanding of the tools is important and necessary, I found that augmenting the technical learning with practical business domain understanding was critical in allowing me to develop a fluency in the product that I was working with. Between each and every goal, between each and every gap in knowledge were small incremental steps towards understanding. Mindfully we take these steps and enjoy the process of stepping forward with our foot grounded in our very best understanding of the problem. Maybe it’s bad engineering, and most people reason with problems differently. I don’t know, it’s hard to say exactly what route is the best route and that’s why it’s mostly just important to find what works with you and to reinforce it. The debugger works for me but admittedly even I’m questioning that tactic, and recognizing that my style will evolve over time and that’s a process you’ve got to fall in love with.

Cheers,

Alvin

The felt experience of software development

Tue, 01 Feb 2022 09:33:42 -0500

Software engineering has boomed. If you’re between the ages of 24 and 45, then likely you are or know someone who is a software engineering. Let’s remember exactly what software engineering is. The development of an idea into an actuality. Our generation has seen such a scale of rapid development in the application development world that anyone with an idea and knowledge of programming can potentially disrupt longstanding industries. This is the age of the idea. The demand for software engineers is huge. Training schools, known as boot camps, aim to upskill even the most novice of software engineers. This drastically reduced the barrier to entry for this field. A more diverse talent pool of applicants presented itself in a time when inequality gaps stemmed from systems that inadvertently oppressed women and people of color. I am one of the thousand of people who decided to pursue software engineering as a career path with little prior training as a Fine Arts major who went into marketing and communications. I’ll share honestly and transparently. Perhaps as a way to provide historical record of this time and place that we find ourselves in. This blog will certainly evolve over time, and I hope to evolve with it. I hope you do too somehow. :-)

Thank you for being here in this space.

Cheers,