Matt Whitworth

Code coverage doesn’t tell you as much as you think. Mutation testing sounds like a good verification measure. Has anyone used a mutuation testing framework for C/C++ or do you use Test Driven Development? Seems like TDD is the best approach.

5

Learn how to utilize the slash commands in GitHub Copilot for Visual Studio with ease! Check out Bruno Capuano's latest video tutorial, focusing on how /AskVS enhances your coding experience by facilitating code refactoring and providing helpful suggestions. https://lnkd.in/gRDrzvNU #github #copilot #ai #msftadvocate

10

2 Comments

The "Refactoring" Expansion to "JitterTed's TDD Game" is going into Play Testing soon! New tiles include "Refactor" (duhh!) and "Integrate" (h/t Tim Ottinger). #Refactor "recipe" cards are the next step. Two layout ideas: Refactor as an optional path (see picture), or Refactor always on your path, though still "optional". Leaning towards the latter. If you buy a physical copy of the game now, you'll get a discount on the expansion (see link in comments). You'll also get early access to the online version. #TDD #Refactoring #BoardGames

7

2 Comments

Why context matters when you're a developer (and why #DDDesign is a very practical approach) Thanks to Guillaume C. for the link 😄 https://lnkd.in/eZbdz-BT

7

The October Montreal.rb talk will be on how to "Tame Complex Queries with Database Views", given by David Cornu, a Staff Software Developer at Patch. Date/Time: Wednesday, October 2, 2024 at 7pm Location: Anticafe Montreal (294 Saint-Catherine St W, Montreal, Quebec, Canada) RSVP link: https://lnkd.in/er8Hz24N Description: PostgreSQL views are a useful tool to make query logic reusable and maintainable. This talk will cover their pros and cons, a couple of real-world use cases, and how to use them in Rails apps using the Scenic gem. Speaker: David is a staff software developer at Patch (a climate tech startup). He cracked open Why’s Poignant Guide to Ruby in 2009 and has been in and out of Rails apps since. #montrealrb #montreal #ruby #rails #talk #presentation #softwareengineering #softwaredevelopment #programming #community

1

This is a final reminder for the October 2024 Montreal.rb Ruby Meetup, "Tame Complex Queries with Database Views", taking place tonight at 7pm at Anticafe, Montreal: https://lnkd.in/dXhQ6k2G Please remember to follow these instructions when you arrive at Anticafe by 7pm (294 Saint-Catherine St W, 3rd floor, Montreal, Quebec):  - Upon entry, please check in on Anticafe's computer in the 2nd floor (free coffee and snacks are available in the 2nd floor).  - After checking in, please head to the 3rd floor to attend the Montreal.rb event  - When the talk ends (around 8pm), please leave immediately to the Networking Event location next door: NYKS Bar (1250 Rue de Bleury, Montréal, QC) - Upon leaving, please mention that you are with Andy to have your fee covered by Montreal.rb. The event is maxed out already, so if you haven't RSVP'd, you can RSVP for the next month's event instead, before the topic is chosen (if you are a Software Developer with 6 years of experience, you are welcome to present; just submit a title, description, and bio to get your talk booked): https://lnkd.in/d7RrRnQW See you all tonight! #ruby #montreal #meetup #talk #rails #db #sql #database #databaseviews

1

4 Comments

A linkedin connection pinged me and had this discussion about an important aspect of REST API documentation: Q: When documenting objects, if a property has multiple options, can we assume developers know them already? Should we keep it minimal with a one-liner description, the default value, and just mention the options? My take: Minimalism has its place, but in this case, it’s bad UX. Listing options without describing them assumes developers have prior knowledge, which may not always be true. For REST APIs, the documentation is the UI - the only UI. Anything developers need to understand has to come from the documentation itself. There's no other UI to play with and explore and learn anything. Here’s why covering everything is critical in REST API docs: REST APIs have no visual interface. Developers rely entirely on the docs to understand the API. If something isn’t described, they’re left guessing or wasting time figuring it out. In this specific case, the person asking mentioned they were new at a place where minimal documentation was the standard. They’d pushed back based on their past experience but wanted confirmation before taking a strong stand. My advice? Describe all the options clearly. Good documentation isn’t just about listing data—it’s about making developers’ lives easier. What’s your perspective? How do you balance clarity and minimalism in API documentation?" #APIDocumentation #RESTAPIs #DeveloperExperience #TechWriting

50

5 Comments

Fascinating summary of why Figma decided to move from ECS to EKS (#Kubernetes) here are the four key points that stand out to me: 1. Hiring ECS experts is very hard! I believe this. 2. Using open source softwares, we find that most things nowadays are available as a Helm chart distro, while very few OSS projects support ECS officially. (I understand this viscerally, Helm was essential to my Kubernetes onboarding journey and still is.) 3. Autoscaling - the ECS platform supposedly does support it, but they were not using that feature at all. Why? (Might have to read the source document to understand) this turned out to be very costly, anyway. 4. Logging through CloudWatch, Datadog, and Snowflake also turns out to be very costly. Dynamic scaling is a well traveled road in the Cloud Native community, with projects like Karpenter, KEDA, the built-in solutions like Horizontal Pod Autoscaler... I have never used any of this in anger, but I have studied it and shared it for the KubeCon audience. Does this resonate with anyone else? I too would like transparency into the version of software running and to be able to easily access that information across my clusters. This is a valuable property of GitOps solutions like #Flux when implemented well, but the implementation of a multi-cluster and/or multi-tenant use case is still a challenging one, requiring more than a bit of study to master. Does anyone in shouting distance have good or bad experiences to share with that in mind, on either platform or others? (I'm interested to hear from you!)

9

🌟 New Article Alert! 🌟 I've just published an article on Medium: Demystifying Clean Architecture in Go: Separating Fact from Fiction. 🎉 https://lnkd.in/e6pnqEPz In this piece, I dive into the fascinating (and often misunderstood) world of Clean Architecture, exploring how its principles can be adapted to the simplicity and power of Go. From flat project structures to more elaborate designs, I've included practical examples to illustrate how we can balance clarity, scalability, and testability. Whether you're a seasoned Go developer or just curious about software architecture, I hope you'll find this article insightful and relatable. 💬 I'd love to hear your thoughts, experiences, or even challenges you've faced while applying Clean Architecture principles in your own projects. Let's keep the conversation going! #golang #go #cleancode #cleanarchitecture #softwarearchitecture Check it out and let me know what you think! 👇

6

Some things I would love people to build. 1. End-to-end no code development: Vercel has v0.dev - the ability to quickly spin up front end. Make changes all with prompts. I use this frequently when ideating. The code it produces isn't that great, it's "okay" but still requires a lot of dev work. The next issue is, if you're building a big app with multiple features, it gets lost + can't "glue" everything together into one big prototype. Problem one: Code quality + context of the whole app in one place. Problem two: Creating the right backend to plug into this application (a monumentally challenging task). Problem three: APIs (where it's pulling data from) - every doc is different, if they have API documentation at all. 2. Auto experimentation - let's say I have a landing page. I can ask an AI to take our brand colours / existing landing page and then create multiple versions. Launch them. Run tests and shut off landing pages to continually optimise the experience for the highest % conversions. The next would be in your actual web application. Moving buttons around, changing workflows to test on users against things like adoption, upsell, X-sell. 3. AI Agents (that don't suck) - there are a ton of companies working on these at the moment. I've been playing around with them and you still require significant levels of coding knowledge (to make a decent one). 4. A workflow tool for AI Agents - I can create entire departments and then set tasks that they need to do for each other. KPIs and management layers so I only see when something is (or is not) broken. 5. Finance AI It's just numbers, forms and excel. - Read my mailbox for invoices / receipts - Update Xero / quickbooks - Tell me when my subscriptions are up - Modelling - Contracts up for renewal - Look at my stripe data - Look at my bank info 6. Founder chaser I want something that will annoy me until I've done a task and check I've done it. I get requests or tasks from all over the shop. To-do lists are "fine" but I want a conversational AI that will be on my case. "I want AI to do my laundry and dishes, so I can spend more time on art and writing. Not for AI to do my art and writing so I can do more laundry and dishes."

7

7 Comments

I have no skin in the game with TDD. But if you see people saying things like "TDD doesn't work" or "you don't just jump in to TDD" that's just slang for "I haven't figured out how to get TDD to work and I'm arrogant enough to think if I can't do it it can't be done." Ignore if they give you reasons. Many people would rather put a limit on something than on themselves. But also recognize that there are different ways to do TDD. It's not a one size fits all. The key, however, is to write tests before writing code. Red-green or pairing are options (good ones) but not the only way to do it. But test specifications before writing code is always a good idea. Good tests inform good design. What you should be asking is "those of you who are using TDD, how do you make it valuable?" Or ask Daniel Terhorst-North or David Scott Bernstein about it.

21

93 Comments

This weekend, I'll fly back to Canada from Europe. Thanks to Shrinidhi M V I bring an e-book with me: 👉 System programming with C# and .NET by Dennis Vroegop Here's the table of content: ♦ Chapter 1, The One with the Low-Level Secrets, dives into the low-level APIs, the BCL and CLR, and how to use Win32 APIs. ♦ Chapter 2, The One Where Speed Matters, examines how to make your software perform as fast as possible. ♦ Chapter 3, The One with the Memory Games, talks about memory handling, the garbage collector, and how to be as memory efficient as possible. ♦ Chapter 4, The One with the Thread Tangles, looks at threads and asynchronous programming. ♦ Chapter 5, The One with the Filesystem Chronicles , teaches input/output, file handling, encryption,and compression of files. ♦ Chapter 6, The One Where Processes Whisper, talks about how to make programs communicate on one machine or over a network. ♦ Chapter 7, The One with the Operating System Tango, dives into the operating system’s services and how to use them. ♦ Chapter 8, The One with the Network Navigation, discusses everything we need to know about networking in your application, both as a server and a client. ♦ Chapter 9, The One with the Hardware Handshakes, deals with connecting to outside hardware and communicating with other devices. ♦ Chapter 10, The One with the Systems Check-Ups, talks about logging and monitoring your software. ♦ Chapter 11, The One with the Debugging Dances, is all about debugging your software. ♦ Chapter 12, The One with the Security Safeguards, talks about the security of your software. ♦ Chapter 13, The One with the Deployment Dramas, teaches you how to deploy your software to the production machines. ♦ Chapter 14, The One with the Linux Leaps, discusses the operating system that most of our software will run on: Linux. I expect to read about essential skills in systems programming, covering low-level APIs, memory management, multithreading, and network protocols. Looking to constantly build robust, high-performance applications, I'm hoping to go through real-world application, cybersecurity and cross-platform development. #csharp #packt #dotnet #microsoft #softareengineer

83

21 Comments

New Tutorial: Setting Up Templ Using Nix Flakes. I'm on a little side-quest to see if Go (and/or Rust) are a viable alternative to a NodeJS or PHP heavy stack for small-scope/heavy-traffic websites. While setting up Templ I figured this was a good topic for a Tutorial. P.S. Also peep the new cherry blossom theme! https://lnkd.in/gG8R2QuA

2

Hey recruitiers / hiring managers... adding this kind of info to your posts sure would be swell for everyone involved since "engineering manager" and "software manager" mean such different things in different organizations. Even with descriptions and required skills this info clarifies what matters and how much. A job requires Java for example. If you say technical is 5 stars someone that isn't strong in code isn't (or shouldn't) apply. If you say technical is 1 star, someone that wants to stay in code while managing isn't going to apply. And importantly for both visa versa. More context can only help you be more likely to get candidates that match your expectations. Take a look at the 5 different types of Engineering Manager and then specify it and mention the blog (no clue who the blog poster is btw, no affiliation) or use the idea of the different areas to stress. eg: The Delivery Engineering Manager Technical 🌟 Team 🌟🌟 Process 🌟🌟🌟🌟🌟 Product 🌟 https://lnkd.in/eSj2i9yj

3

If you're a TDD hater or even just a skeptic, I'd love for you to attend the session linked in the comments (2 hours from this posting) & then let's have a conversation here. I'll cover the history of TDD, some misunderstandings, and future work.

545

142 Comments

Let's face it: "software engineers" and "software developers" are *not* craftspeople. We are usually a business cost-center that converts business requirements into customer dollars. Setting aside the political baggage of the Software Craftsperson (nee "Craftsman") movement (and those original words alone convey some of the baggage), I find now that I regret the entire movement itself. Paid software development is about serving a business need and rarely about crafting software that is optimized for flexibility, reliability, and understandability. When businesses seek to turn a need into software, they are often concretely planning for a quarter, loosely planning for a year, and pipe-dreaming when they "plan" for anything over three years. This has an impact on software developers. The cost of converting ideas into software usually scales something like logarithmically to exponentially with the complexity of the business. Software is usually developed with an eye toward achieving a quarterly or annual goal or an investment round--so let's say 3 to 12 month window. Management expects to be able to measure results. And, so, in most environments, you need deliverables that can be demonstrated to management in order to show progress. Except for those ideal cases where eXtreme Programming actually works (e.g., customer is always onhand for clarification, no artifacts other than code and test code, team of up to maybe 8 people, often working in pairs, etc.), the complexity of converting business needs into code is complicated bordering on complex because businesses are complicated bordering on complex. (I use the Cynefin definitions of "complicated" and "complex" where "Complicated" means something like"with a reasonable amount of effort, you can somewhat reliably predict outcomes" and "Complex" means that "this system/business is so complicated that you cannot reliably reason about its properties and so properties and outcomes are emergent) Given anything but a project or business with an exceedingly clearly bounded minimum viable product, we're rarely crafting but instead struggling to meet quarterly/annual/funding round deliverables. But wouldn't it be wonderful if we could find our way back to when software developers were able to ship software they could be proud of and businesses were better for it? Perhaps it's still possible. But we all have to be playing a long game, business and developer.

13

2 Comments

Don't be that teammate who blindly refactors code and only makes things worse. Let's look at some good vs bad refactoring patterns with real examples. All of the code snippets below and more in the full blog post: https://lnkd.in/gsaQv3SA

847

34 Comments

The issue is that all these arguments and analogies are straying further and further from what open source is, and what it is about. Looking at your list: 1. API documentation 2. End user documentation 3. Code comments 4. Source code Which of the 4 are needed to comply with the OSD and even the Four Freedoms? Just #4, the source code. All the rest are nice to have but no matter what a random group of people may rank them as in terms of importance, it is the Source Code, and the Source Code alone which is core. But now the argument seems to imply that since the others may be nice to have, or somehow deemed "more important" (whatever that means), that they must also be available for something to warrant the Open Source tag and that this only applies (or is a problem) with AI. All these attempts, IMHO, to try to justify inclusion of weights and training data in any definition of "Open Source AI" just mangles the whole definition of open source for this single outlier. IT IS NOT WORTH DAMAGING, CONFUSING, AND MANGLING OPEN SOURCE FOR THIS SINGLE SPECIAL CASE where people try to lump data/weights as being on-par with the source.

1

21 Comments

Back in 2020 I started an opensource github repo called "feedback". Almost five years later I have a bunch of sites using this go web framework in production. It's a *very opinionated* framework. David Heinemeier Hansson (DHH) made a lot of choices when he did rails. Linus Torvald made a lot of choices when he made linux. Here is a discussion about the framework on a tech site called lobsters: https://lnkd.in/gN5QgwvX "this HAS to be some kind of prank" was a comment from someone referring to one of these opinionated choices I made. Going on record here on linkedin: it's not a prank. Everything in this framework is from real world coding in the trenches with battles and scars.

8

7 Comments