Category: Software Development

Emotional Equations

Posted on by Jason Valdez

This one always comes to mind:

Disappointment is the difference between expectation and reality

I think this is attributed to Chip Conley from “Emotional Equations”. I’m preparing to read this book. Interestingly, I hit this very same point (equation) when dealing with team members. It is an entirely different context than the book, which I should add.

One of the interesting constants in business is having to deal with the duel expectations of your coworkers and yourself. Almost in every instance, your expectations and your coworkers expectations will not align. This misalignment is a catalyst for disorder and conflict.

I’d like to keep exploring this idea in my next few posts.

Search and Replace with Regular Expressions in VSCode

Posted on by Jason Valdez

One of the little gems in Visual Studio Code (VSCode) that I like, is the regular expression support in the search box. It is very powerful, but the thing that I like most is how simple it is.

There isn’t a large dialog with several options. It’s just a small button that changes a simple text search into a pattern matching search.

Here is the link to the video

Note: I wanted to try uploading a video on Youtube for this. I’d like to produce content on Youtube in the future, but I have no experience with it. The embedded video is basically me experimenting with the platform.

Quick note: Bitbucket and Github Pull request

Posted on by Jason Valdez

I thought that maybe I was just not used to the interface.

I thought that maybe I just preferred the way I had been doing things.

I thought that maybe I didn’t see the features for the trees.

Over the years, I’ve become very used to Bitbucket’s style of pull requests and the interface that is used to process them. It isn’t perfect, but it is very navigable and generally I like the way it works.

Over the last six to twelve months or so, I’ve been using the Github pull request interface. It is drastically different. Where Bitbucket puts each file in a separate screen. Github puts the each Diff in a continuous layout. You simply scroll through the changes until you have seen all of them.

I think part of the problem is that Bitbucket is focused more on corporate projects begin run internally, while Github is all about open source projects being run by distributed individuals or teams.

Github’s interface is better for small changes and Bitbucket’s seems to be better for large changes. That seems to be the basic driver. Open projects with many developers tend to commit smaller changes in a more organized manner. Private projects, run internally of a company, tend to commit large changes for new or existing features.

I could be totally wrong. It may be that I just don’t know all of the Github features.

Cross-platform targeting

Posted on by Jason Valdez

SQL BulkLoader was my first attempt at multi-targetting a nuget package.

https://github.com/JasonDV/SQLBulkLoader

There are some interesting best practices around this concept.

https://docs.microsoft.com/en-us/dotnet/standard/library-guidance/cross-platform-targeting

Normally, when working on line-of-business applications, I have a lot of control over what .NET target I’m using. I choose mostly based on which targets are current and what is installed on the deployment infrastructure. Getting configuration changes to deployment environments is often time consuming; therefore, I avoid it unless upgrades justify the time.

In the future, I’ll explore some of my justifications when putting together a solution and choosing technologies, structure, and environment.

What I tell Jr Developers

Posted on by Jason Valdez

Software developers love sharing knowledge. If it wasn’t for this one key fact, there wouldn’t be such a large supply of helpful information online for free, which is almost always better than that available for pay.

There are always a lot of younger developers entering the industry. Many of them will do very well without anyone’s help. Others will struggle for years, under utilized, under a paid, under appreciated, and not growing their skill sets.

When I get the chance, I like to chat with junior developers about things they should be aware of and/or actively doing.

  • Software development isn’t all about technology, design patterns, and architecture.
    • Complex software often requires a team of people.
    • The most important thing to be produced from a software development project is working software.
    • Making working software effectively and consistently requires a good software development process.
    • Learn your software development process. Learn how to continuously improve it.
  • Take chances by executing on things that aren’t happening.
    • As a junior developer, the majority of the time you will gain responsibilities because there is no more-senior developer to take them on.
    • As you become more senior, you will have the opportunity to do things that the company isn’t doing because no one is willing to take them on.
    • In all organizations there are people that have defined responsibilities. For those people, that responsibility will be the most important aspect of the company’s inner workings.
      • They will ruin your efforts if they think it is causing them problems or extra work.
      • If at all possible, try not to explicitly give others extra work.
        • You don’t do this out of respect.
        • You do it because they won’t do extra work for you.
  • You won’t learn everything you need to know at your job.
    • All organizations that produce software experience some type of technology lock-in. This is often the result of two concurrent forces.
      • The first is developers who don’t want to to learn new way of doing things.
      • The second is management who desire to standardize on processes and technology.
    • Standardization without continuous improvement leads to organizations that are resistant to change.
      • Change is necessary to achieve long term goals, match industry changes, and client business needs.
  • You won’t learn everything you need to know at one job.
    • Do not plan to stay at your first few positions. Work until you feel you are not learning anything new, then leave for more experiences and always more pay.
    • As a junior developer you need a breadth of experiences. The only way to get those is to work with different businesses, technology, and other developers.
  • Have side projects
    • You must have something to constantly keep your mind active and an outlet to explore things that your job won’t allow.
  • All the real problems in software development are people problems.
    • Technology problems are not major issues for a software development project.
      • A technology problem is just an undiscovered technology solution.
    • The types of problems that kill progress on software projects are people problems.
      • Miscommunications
      • Stalling over decision making authority
      • Interactions with groups outside the immediate software project leading to delays.
      • Ego, fighting, disagreements, etc.