The Future Did Indeed Just Happen

In his insightful article, titled perfectly “The future just happened: Developer Experience and AI are now inextricably linked.“, James Governor writes about the profound ways in which artificial intelligence (AI) has become intertwined with the developer experience (DX), fundamentally altering the landscape of software development. He highlights how tools like GitHub Copilot, powered by OpenAI’s Codex, have revolutionized coding by providing real-time code suggestions and automating mundane tasks. This advancement has not only boosted productivity but also enhanced the learning curve for new developers, making complex coding tasks more accessible and manageable.

It’s a solid read, so go read it now. Then swing back and continue, as I’ve got a thing or three to tell you about AI and where development is going.

The Future Happened, So What About Tomorrow?

The integration of artificial intelligence (AI) into software development is already transforming the way developers write and manage code. Tools like GitHub Copilot, powered by OpenAI’s Codex, offer real-time code suggestions and automation for repetitive tasks. This has not only increased productivity but also democratized coding, allowing less experienced developers to tackle complex problems more efficiently.

Impact on Developer Roles

AI’s influence has shifted the dynamics between junior, senior, and principal developer roles. Junior developers now have access to sophisticated tools that help them write better code faster, reducing the gap between them and their more experienced counterparts. As AI handles more routine tasks, senior developers can focus on high-level problem-solving, architectural decisions, and mentoring juniors. Principal developers are now more involved in overseeing the integration of AI tools and ensuring they align with the company’s strategic goals.

In many ways however, this can also be seen as an increasing risk for junior developers and a growing – not a reduction in the – gap between them and senior developers. As seniors can make even more effective use of AI tooling based on their experience with pre-existing tools while junior developers don’t always know where to start or refine their query with AI tooling. Dare I say, that prompt engineering can be a real beast.

The Immediate Future

In the next 1-2 years, AI is expected to further revolutionize software development. Predictive coding, where AI anticipates and suggests entire code blocks based on previous patterns, will become more prevalent. This will speed up the development process and reduce errors. Additionally, AI-driven testing and debugging tools will enhance code quality and security by identifying vulnerabilities and performance bottlenecks more efficiently than traditional methods.

All that said, it could also lead to greater errors that are unrecoverable. It could lead to all sorts of problems we’ve yet to see. So buckle up Bucky, things could get bumpy!

Ethical and Practical Considerations

As AI becomes more ingrained in development workflows, ethical and practical considerations will arise. The potential for job displacement, the need for ongoing AI training, and the importance of maintaining a human touch in coding decisions will be critical discussion points. Companies will need to balance the benefits of AI with these challenges, ensuring that developers remain central to the development process.

The future of software development is undeniably intertwined with AI. As these technologies evolve, they will continue to redefine the roles and responsibilities within development teams, driving innovation and efficiency in unprecedented ways. If you’re not using AI tooling for your software development today you’re likely, and irreparably falling behind.

In the coming weeks, I’ll have some very thorough programming reviews around the AI tools on the market right now. So be sure to subscribe and stay tuned! Cheers, and happy thrashing code!

An Engineering Manager Challenge

This post came to mind while reading this post on LinkedIn, which is a share of this post by Kelvin Mai, and the follow up post Ted Neward made here. Read up on those for more insights into this topic.

Before diving into the details, it’s important to note that the criteria outlined here leave several questions unanswered, which could significantly impact the final decision. Factors like the specific nature of the projects, team dynamics, and long-term strategic goals are crucial and could sway the decision in different directions. That said, let’s break down the options.

Bringing on Two Junior Developers

Pros:

  1. Boosted Bandwidth: Two fresh faces mean more hands on deck to share the workload, increasing overall throughput.
  2. New Blood, New Ideas: Junior hires come with fresh perspectives and a ton of enthusiasm that can rejuvenate the team.
  3. Long-term Investment: Junior devs are like seedlings; with the right nurturing, they grow into valuable assets, contributing more as they develop.
  4. Flexibility: Juniors can be shaped to fit the team’s needs and culture, making them adaptable assets.

Cons:

  1. Boosted Bandwidth: Emphasis here though is on “throughput” above in the pros and not on committable, usable, and well written code you want and can use in the project. Increased throughput can be a negative, and IYKYK and can think of this as “induced demand” but for code.
  2. Training Time Sink: Juniors need a lot of guidance, which can be a major time drain for the senior members.
  3. Ramp-up Period: They won’t hit the ground running. Expect a learning curve before they start delivering at full capacity.
  4. Management Load: More people means more management. Even if they’re juniors, it adds to the admin overhead.

Hiring One Senior Developer

Pros:

  1. Expertise on Tap: A senior dev brings a treasure trove of knowledge and experience, perfect for tackling complex challenges and making strategic moves.
  2. Mentorship: They can mentor junior team members, leveling up the entire team’s skill set.
  3. Quick Impact: Seniors can dive in and start contributing much faster than juniors, thanks to their experience.

Cons:

  1. Higher Price Tag: Senior talent doesn’t come cheap. They’ll command a higher salary, impacting the budget more significantly.
  2. Cultural Fit Risks: There’s always the gamble that a senior hire might not mesh well with the existing team dynamics.
  3. Single Point of Failure: Relying on one senior dev for critical tasks can create dependencies, potentially leading to bottlenecks.

The “Do Nothing” Route

Pros:

  1. Save the Budget: Not hiring anyone saves money, which could be redirected elsewhere.
  2. Focus on Current Team: No new hires mean you can double down on developing and optimizing the current team.

Cons:

  1. Opportunity Cost: Leaving budget on the table means missing out on potential gains in capacity and productivity.
  2. Burnout Risk: Your current team might end up overworked, risking burnout and decreased morale.
  3. Stagnation: Without fresh talent, innovation can stagnate, and the team might struggle to keep up with growing demands.

The Decision

Let’s get real: not hiring anyone is likely the worst choice here. I know some would disagree in some situations, but if you’ve got budget allocated for new talent, use it! Even if the ROI isn’t immediate, it’s about positioning the team for long-term success. Hiring is an investment in the future—whether it’s two eager juniors ready to grow or a seasoned senior ready to lead and mentor. In this scenario, hiring one senior developer is the strategic move. You’ll get immediate expertise, mentorship for the juniors, and a stronger foundation for future growth. Let’s make that budget work for us and set the team up for success!

Addendum

This post attributed to leading me down the path to elaborate on staff and hiring details, including The Toxic Truth About Coding Challenges in Technical Interviews and then the elaboration on that post with The Reality of “Code Challenge” Culture Outcomes Among Large & Small Organizations.

What’s The Practice with Rider & .NET Solutions/Projects? How to resolve IDE errors?

Alright, I’ve fought with these kinds of things since the inception of .NET, the key difference now is that there are the variances in .NET versions and also IDEs. The question is, how should I setup my solution and respective projects?

First – .NET Solution

Usually what I do is create an empty solution. Name it, check the options accordingly to create a directory and make it a Git repository.

Then, as a kind of general practice I create a class library to build out logic and what not, and add a test project and then whatever the interface is going to be. That might be a web app, a GUI, or console as I’ve got selected here. Sometimes, if useful I go ahead and create a Dockerfile.

At this point, there are a few key problems I always bump into. Obviously, since I have a repo I need a .gitignore file, preferably a README.md, and maybe even a license file right? How does one add, so that the IDE is aware of them, any extra files at the solution level? What I usually do here, is use the terminal to just build out the solution level files, but then the IDE doesn’t know about them. Similar problems come up in the other .NET IDEs like Visual Studio and such.

Second – Open a Folder Solution

The second type of solution I find myself creating is started by opening a repo folder.

Empty, with nothing else that looks like this.

Creating a .gitignore and other respective files is easy at this point. As a right click will allow me to do just that. I’ve also added some projects.

At this point everything works great. As you can see below the runner is wired up, the IDE is aware of the tests, and runners are available for that.

One problem I’ve run into however with this technique, is sometimes I close this type of project – one started by merely opening the folder – and all this awareness just disappears. On the same machine, same folder, no deletion of the .idea folder or anything like that. It just loses all the awareness.

So my question is, which method do you use to start a project and how to do you, fellow .NET coders, work around these types of issues?

Software Development: Getting Started by Getting Organized

A few weeks ago I wrote up the post on the tech I’ve decided to move forward with for my new project. This post is going to cover the collection of features, domain details (i.e. what is the use case, etc), and related project collateral. Instead of just slinging code like many of us programmers often do, I’m going to layout what I’m trying to build, what features I want, and how I’m going to put those features together before delving into actual code. This way, my hope is I’ll be able to keep track over time better, and if any of this turns into something I’ll then have something to keep working from instead of throwing a code base over the fence to other devs. A crazy action that happens all the time, but is something worth avoiding!

I was about to take the path of “well everybody uses JIRA to keep track of tasks I’ll use it…” but then after looking at it for about 5 seconds I remembered why it drives developers absolutely nuts. Especially if you’re on a real small team, you end up spending inordinate amounts of time managing those tasks vs. doing any work toward accomplishing those tasks. In light of that reminder, I’m going to just go with Github issues. The first stumbling after making that decision I present to you the first selection for the project.

After a quick few seconds I opted to use the feature based project and clicked to edit the project details. This seemed like the best to start with since I’d just be adding features I intend to build and using the list as a kind of task list versus a product management or operations style list. Of the other options, this one seemed to fit best.

Next up was figuring out how I’d track items in the project solution here on Github. Looking at the interface I could see where to add items to track. I immediately fired off to create a new item by clicking the plus, entering a title for it and hitting enter.

From there I added a few more, which you can check out here. The intial work is just putting together the techincal collateral to even more forward in any purposeful way. That includes numerous tasks, with several listed in the image of the project.

The plain list of items on Github for this first few days of work look like this. I’ve only put in this many, just to stay focused on these initial elements of work.

Now that I’ve got some organizational things going on, it’s on to next steps. I’ll detail those in some subsequent articles I’ve got in the pipeline, so as always subscribe and stay tuned!

Past article: Starting a New Project – Let’s Choose a Tech Stack! Next article: Coming soon!

Performance Monitoring and Tuning in Relational Databases: With Observability Lagniappe

This is a continuation of my posts on relational databases, started here. Previous posts on this theme, “Data Modeling“, “Let’s Talk About Database Schema“, “The Exasperating Topic of Database Indexes“, “The Keys & Relationships of Relational Databases“, “Relational Database Query Optimization“, “Normalization in Relational Databases“, “Database (DB) Caching and DB Tertiary Caching“, “Security and Authentication in Relational Databases“, A Guide to Backup and Recovery Options for Relational Databases: Focusing on SQL Server, Oracle, MariaDB/MySQL, and PostgreSQL, and Concurrency Control in Relational Databases.

In the ever-evolving landscape of software development, the performance of relational databases isn’t just a feature; it’s a critical component of system health that can dramatically influence user satisfaction and operational efficiency. We’re starting a deep dive into the world of performance monitoring and tuning for relational databases, uncovering practices essential for maintaining robustness and speed during database interactions in this post.

Understanding the Basics of Database Performance Tuning

At its core, performance tuning in relational databases revolves around optimizing the queries and processes that interact with your database. This involves a suite of tasks including query optimization, indexing, configuration management, and resource allocation—each aimed at minimizing latency and maximizing throughput. These are the keys to ensuring your database can handle complex query requests and high loads with grace.

Performance tuning is a continual cycle of adjustments and improvements. It starts with performance monitoring: the systematic tracking of system performance over time. By keeping tabs on metrics such as query execution time, wait times, disk I/O, and CPU utilization, developers and database administrators can identify and rectify bottlenecks.

Integrating Observability into Database Management

Moving beyond mere monitoring, observability offers a more nuanced approach, involving logging, tracing, and metrics to gain deep insights into the database’s operational state. This comprehensive view is critical for diagnosing unexpected behaviors or slowdowns effectively.

For example, detailed logs and traces can pinpoint whether slow queries result from poor indexing or if a specific service is overtaxing the database, impacting overall performance. This deeper insight helps us understand the ‘why’ behind performance metrics, providing a multi-dimensional perspective on database health.

Connecting Database Observability with API and Interface Performance

The observability of a database directly influences the performance of application APIs and interfaces. If an API’s response time falters, it might be linked to a query inefficiency or a resource bottleneck within the database. By leveraging observability tools that integrate data across both the database and application layers, developers can correlate issues, streamline performance, and enhance service reliability.

This integrated observability approach ensures quick identification of whether performance issues stem from the database, application code, or the interplay between services, facilitating a well-aligned tuning strategy that caters to the comprehensive needs of the application and its user base.

Expanding Observability Across the Development Stack

In modern settings where microservices and distributed architectures prevail, the demand for expansive observability is heightened. Every layer of the stack, from the frontend to the backend, demands meticulous monitoring and tuning to guarantee peak performance.

Implementing observability across the development stack enables teams to detect and address issues proactively, fostering a culture of continuous improvement—crucial in today’s fast-paced development environments.

Leveraging Tooling Like Hasura for Advanced Observability

Integrating tooling from software solutions like Hasura can elevate PostgreSQL database observability, particularly in modern application architectures where databases are interfaced through APIs. Hasura, known for its real-time GraphQL API layer over PostgreSQL, offers invaluable tools for observing and tuning SQL queries it automatically generates and executes.

Enhancing SQL Management with Hasura

Hasura’s real-time monitoring capabilities allow developers to view the execution of queries dynamically, a crucial feature for understanding how different parts of your application interact with the database. Moreover, it provides detailed logs of SQL queries, including execution times, which aids in identifying and optimizing slow-performing queries.

Hasura’s ability to integrate seamlessly with existing observability tools like Prometheus, Grafana, and centralized logging solutions like ELK further strengthens the monitoring framework, providing a holistic view of database performance and aiding in swift diagnosis and optimization.

Best Practices for Using Hasura with PostgreSQL

  • Regular Review and Optimization of Queries: Regular assessments of SQL queries that Hasura generates ensure they are performance-optimized.
  • Data Model Optimization: Tailoring PostgreSQL schemas to suit common query patterns generated by Hasura can significantly enhance performance.
  • Continuous Monitoring and Tuning: Leveraging Hasura’s performance metrics and logs for ongoing tuning of database configurations and queries ensures optimal performance.

By methodically applying these tools and practices, you transform from a reactive to a proactive stance in database management. This ensures that your relational database environment is not just monitored and observable but also finely tuned for optimal performance. This approach is essential for maintaining an efficient, robust, and scalable application infrastructure, ready to meet the demands of modern business needs.

References

  1. PostgreSQL – Official PostgreSQL Website
  2. SQL Server:
  3. Oracle Database:
  4. MariaDB/MySQL:
  5. pgBadger – pgBadger GitHub Repository
  6. PostGIS – Official PostGIS Website
  7. Prometheus – Official Prometheus Website
  8. Grafana – Official Grafana Website
  9. pgAdmin 4 – Official pgAdmin Website
  10. Hasura – Official Hasura Website
  11. ELK Stack (Elasticsearch, Logstash, Kibana):
  12. Loki – Grafana Loki
  13. Jaeger – Official Jaeger Website
  14. Zipkin – Official Zipkin Website