Aytekin Ozdemir

I've been thinking a lot lately about ways of structuring IaC code, specifically - should this code be separate from application's code, or they can (should) be kept close to each other. When writing backend code, my rule of thumb about managing transactions (and other resources, like connections) is that a method or class cannot interfere with its (transaction's) state if that transaction has been started somewhere outside of that code. In simple words, only a piece of code that started a transaction should make a decision to commit or roll it back. Looks like this model can be applied to codifying infrastructure as well. If an application owns the lifecycle of an infrastructure resource, it is okay to put them in one source code repository. Short unpolished writeup on this topic: https://lnkd.in/emzDC9Nn

2

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.

546

140 Comments

I once asked a lead engineer on Angular: Which is better: Angular or React? His response: "Both require good engineering to be effective." So, my developer friends, consider this a reminder that "frameworks" like Diátaxis are fine, but they still require good engineering--such as UX, information architecture, style, maintenance processes, and so on--to create great documentation experiences for your customers. Alas, the framework alone isn't enough.

35

7 Comments

If Not React, Then What? Frameworkism isn't delivering. The answer isn't a different tool, it's the courage to do engineering. Code that runs on the server can be fully costed. Code that runs on the client, by contrast, is running on The Devil's Computer. As a result, an unreasonably effective strategy is to send less code. In practice, this means favouring HTML and CSS over JavaScript, as they degrade gracefully and feature higher compression ratios. Declarative forms generate more functional UI per byte sent. These improvements in resilience and reductions in costs are beneficial in compounding ways over a site's lifetime. Stacks based on React, Angular, and other legacy-oriented, desktop-focused JavaScript frameworks generally take the opposite bet. "Our product stack has bet on React and the various mythologies that the cool kids talk about on React-centric podcasts. You're asking us to rethink the whole thing. Which silver bullet should we adopt instead?" JavaScript remains at least 3x more expensive than equivalent HTML and CSS, byte-for-byte. The choice isn't between JavaScript frameworks, it's whether SPA-oriented tools should be entertained at all. For most sites, the answer is clearly "no". Sites built to inform should almost always be built using semantic HTML with optional progressive enhancement as necessary. Sites that have content that changes more frequently should look to "classic" CMSes or tools like WordPress to generate HTML and CSS. Blogs, marketing sites, company home pages, public information sites, and the like should minimise client-side JavaScript payloads to the greatest extent possible. They should never be built using frameworks that are designed to enable SPA architectures. Managers and tech leads that have become wedded to frameworkism often have to work through a series of easily falsified rationales offered by other Over Reactors in service of their chosen ideology. Note, as you read, that none of these protests put the lived user experience front-and-centre. "...it works for Facebook" To a statistical certainty, you aren't making Facebook. Your problems likely look nothing like Facebook's early 2010s problems, and even if they did, following their lead is a terrible idea. "...React is industry-standard" This is, at best, a comforting fiction. At worst, it's a knowing falsity that serves to omit the variability in React-based stacks because, you see, React isn't one thing. It's more of a lifestyle. Across more than 100 consulting engagements, I've never seen two identical React setups. There's nothing standard about any of this. It's all change, all the time, and anyone who tells you differently is not to be trusted. And if you don't mind me asking, how's that "CSS-in-JS" adventure working out? Still writing class components, or did you have a big forced (and partial) migration that's still creating headaches? https://lnkd.in/efB4PR-A

3

Rails 7.2 now makes sure jobs get enqueued after the current database transaction is committed. Previously, your jobs would run before the records were saved to the database causing errors, so Rails takes care of it for you. If you've ever had to remind yourself (or your team) to use `after_create_commit` callbacks instead of `after_create`, this solves that problem. ActiveRecord uses transactions behind the scenes, so it's an easy mistake to make. And with jobs being retried, it's confusing why the job fails then succeeds a second later. This is another great example of conceptual compression in Rails! https://lnkd.in/gyNtiPnr #ruby #rubyonrails #rails

141

9 Comments

What really pisses me off about the way TDD is usually taught / demonstrated is how the REFACTOR part is simultaneously downplayed as "just refactoring" and yet at the same time it magically does all of the design for you. In my experience the developer still has to do all of the design, and that's far from being a beginner level skill. Conversely, every refactoring move has an inverse, and so refactoring by itself is agnostic to code / design quality. In most TDD demonstrations I've seen, the exercise is sufficiently small that the resulting design is either trivial, or was worked out beforehand, or is terrible (bowling scores kata, much?). TDD is just as difficult as good software design. Rant over (for today) 😎

34

11 Comments

Can someone explain to me how to get "more experience"? I have 16 years of full stack software engineering experience, mostly in C# .Net 4.2 through 8, including .Net Core 2.x & 3.x, along with WCF, WPF, Winforms, Razor/Blazor, HTML, CSS, and JavaScript, with Entity Framework, Dapper, Linq, SQL Server, MySQL, SQLite, Oracle, NoSql, and other databases. And a few of those years include a combination of Java, PHP, and C/C++. I've also used MarkDown, PowerShell, MVC framework, Swashbuckle/Swagger, Newtonsoft, JSON .Net, TopShelf, and a variety of testing frameworks. But apparently that's not enough. In the past 3 years alone, I've learned ReactJS, TypeScript, Xamarin, XAML, Maui, NodeJS, Terraform, AWS, and Azure, and I'm currently learning Angular, but that doesn't cover the 3-5 years of experience jobs want. I've learned some of these skills through jobs, but also some on my own. Except that as often as companies want us to learn these skills outside of work, they only count professional experience when it comes to hiring. My last interview said I needed more experience, as if the previously mentioned 16 years wasn't enough, and neither was the 15 years of computer repair and networking before that, which their interview questions also covered. So if no one is willing to hire because people don't already have experience, how are we supposed to get the experience? And don't say "open source projects", because they don't count as professional experience. Or do I have to take a 50% pay cut to take an "entry level" job that still requires 3-5 years of experience that I somehow still don't have? People are quick to say that "no one wants to work anymore" when they can't get hired, but they never seem to think "businesses aren't willing to teach anymore" when they refuse to hire people. Why? Is it that we are so conditioned to think that it's always the individuals fault for not living up to expectations, instead of the businesses fault for setting unrealistic and ever changing expectations? So, I ask again, how can I get the required experience when employers refuse to hire unless I already have experience?

2

Once you hit the #SeniorDev title, your career as a #SoftwareEngineer can go one of three ways. All of these are legitimate decisions and don't ever let anyone tell you otherwise! 1. Management -> This is the oldest and likely the most well-known option. You can head into management and start developing careers of those younger than you. If you love mentoring others and like focusing more on the non-technical management of a project, this is probably the route you want! 2. Staff -> The term "#StaffEngineer" is relatively new to the industry. Many think its title bloat, but I disagree! I think the industry as a whole saw that we needed a new role and we created it. (See my blog on https://iamsellek.com for in-depth info on what a Staff Engineer role looks like!) If you prefer to work in the tec, and you enjoy the bigger-picture aspects of running a codebase/project from the technical side, this might be the route you want! 3. Stay Senior -> Some people look down on this option. Those people are wrong. If you love writing code and doing some light mentoring, there's nothing at all wrong with sticking around as a Senior dev! Some people spend their entire careers here. TLDR? Figure out what you like best about your job. If you prefer mentoring and the non-technical aspects of managing a project, you can head into management. If you want to focus more on the technical side of managing a project and/or a codebase, go with Staff! And if you're happy where you're at, there's nothing wrong sticking with Senior Dev. Now go seize your future! #career #SoftwareEngineer #CareerLadder #future

12

7 Comments

TDD is bad alternative to good debugging. Sometimes nice having a test proving old code fails before proving changed code makes correct difference to verify current assignment is completed. Always be careful to delete all debugging tests before merging into trunk. If request to fix a bug came from QA, then QA already added an entry to their test script to verify the problem is fixed in next release. The entry will likely remain until it fails, then QA decides whether failure is due to requirements changing, or more bad programming. Always think about long-term impact of everything being merged into trunk. We Devs often log what structures are in memory while we work. All logging code must be deleted with its Shelf/Branch when work is done. TDD is poor alternative to good programming. Automated Tests usually indicate the communicator does not understand good programming, except in limited circumstances, such as very low level verification that previously released functionality does not change without marketing the "improvement". This seems important to teach professional Devs corrupted into using amateur Open Source practices like PR (Public Ridicule) so I converted my Comment into a REPOST. Enjoy. 20241212

10

10 Comments

-- Debugging, Testing, and TDD -- Definitions: - Debugging is Programmers proving their code works, to their own satisfaction. - Testing is proving software works. I prefer dedicated QA team. I dislike CD (Customer Debugging) from business perspective of trying to lose customers, or upsetting employees if software has internal customers. - Original TDD was nice concept for deciding parameters before creating a Function. Unnecessary with Top Down Development because calling code exists. Probably good argument against Bottom Up Development. - Modern TDD/Automated Tests have numerous disadvantages, and no benefits not better granted by better practices. Repost to continue this weird conversation. Someone skimmed my writing and incorrectly decided I am "Anti-Testing". I believe: - QA is critical, even if you employ programmers who never write a bug. - Programmers should Debug every line of their code. - Code for Debugging should never merge into DEV trunk. Delete before Merging. - QA is customer advocate, verifies software includes everything required, and everything included work. Code should be Debugged. I use Rolling Logging¹. Modern TDD suggests bad design with numerous tiny Functions, retaining useless code, and slow builds. TDD is neither good Debugging nor good Testing. Software should be Tested. QA writes Test Scripts. Programmed Tests are only for external connections (any API to a program), often simulating attacks unable to be generated by client. What happens if input has missing fields or extra fields? - Comcast: If username was missing, security defaulted to godmode account. Human interfaces must be interfaced by humans. Programs can easily do things which humans cannot. Is each field visible? Is each field reachable? If first attempt is invalid, is error message readable? Once entered, can field be edited/changed? - Discord: Job applications had "Can you legally work in US?" with "Yes" radio button unreachable behind "Submit" button. - PA government: Error message stated if previous field met condition, then checkbox must be checked, but checkbox field was greyed/not editable. I cheated using JavaScript console to check the checkbox. -- The examples are from 2020 or later. [1] How To Program Perfect Software https://lnkd.in/eBeXNAZb 20241223

1

6 Comments

A question to my friends, colleagues, and Linked-In associations that are full TDD developers. Folks who consider themselves proficient or have mastered TDD. 1. How long did it take you to to become very proficient (e.g. to start thinking fully test first)? 2. Did you have a mentor or some aid that helped you along the way? 3. What kept you going down the proficiency/mastery path? I'll start: 1. It took me about 3 years to make it a habit and for me to truly embrace TDD and find that it could replace "test after" development. 2. I did not have a mentor. I did not have YouTube or trainings. I had constraints about creating automated tests. I had teammates that were similarly inclined (constrained). 3. I immediately saw the value of automated tests. I struggled with test first getting in the way of me feeling productive (because I was not proficient and in the learning/gaining proficiency phase) with test first. I'd start every day test first and quickly transition to test after, because it was getting in the way of my "productivity and programming...damn it I just want to write the implementation!" At the end of the day I'd reflect and most days realize that writing tests after was so much slower. Slowly, my time spent test first increased. At some point I transitioned to pseudo coding my intended implementation (to satiate my need to "just write the damn code and not be bothered with tests"). More time passed and I realized that my pseudo code was an inaccurate crutch, I ditched that too and would start with a test. There was a period of time where I'd start with a test and get lost in implementing more than just making the test pass (cycles of sunk cost fallacy here, until I learned it's ok to delete and write it later - faster, better, stronger). There were periods of time where I'd forget to run the test first to see it red before making it green. Too many years messing around with mocking frameworks before learning better design. Struggles with testing internal implementation details instead of external behavior. A whole bunch of stuff I can't think of now and am probably blocking out. I stuck with it though and yikes, does it pay off. I can't imagine not doing TDD now. Coding w/o it is like running through a vat of molasses. So much time wasted in the debugger and writing things that my evil programmer monkey brain distracts me with that YAGNI. I'm writing and asking about this because last week I attended a conference where I talked with a fellow TDDer who'd heard me mention that it took me 3 years to become fully TDD proficient and he shared a similar story even though he was much younger than myself (I attribute my slow adoption due to lack of a mentor/coach and training aids like Pluralsite, YouTube, Jon Reid live coding sessions). I'm curious about others mileage on this. I'll add that I am currently 100% on board with TDD. I am also 100% always on the lookout for a new and better way to replace it. That's off topic though.

45

70 Comments

Something I tell all my consulting clients - if you can work productively with the codebase, then it’s clean enough, even if it doesn’t follow all the principles you read about. The sole purpose of software design is to help you maintain the codebase. Applying DDD to the letter means nothing if you have to spend more time thinking about the proper structure than the features you’re building. I can't stress this enough. Not everything has to match a specific design pattern. Not everything has to be a part of a complex class hierarchy. Not every domain can be modeled after a specific architecture Architecture is a means to an end, not a goal on its own. The reason we try to make our codebases cleaner, more understandable, and easier to work with is so they can be maintained over a long period of time. You'd never refactor a bash script that you have to run once. Why? Because you'll never have to look at it again. Your codebase, however, can live for years. But in our attempts to make everything better, cleaner, and structured, we stray away from that idea. Time and time again, I see teams struggle because of over-engineering rather than under-engineering.

35

1 Comment

A real simple case of how TDD from the inside-out can lead to poor design... I was working on a simple function to nest one data structure inside another based on parent and child relationships. I created the following simple test, and got AI to pass it: > parents = [{'id': id, 'name': 'mother'}, {'id': 2, 'name': 'father'}] > children = [{'name': 'child', 'parent_id': id}] > assert nest_children(parents, children) == [{'id': id, 'name': 'mother', 'children': [{'name': 'child', 'parent_id': id}]}, {'id': 2, 'name': 'father'}] GenAI did a good enough job. It created a list of parents by id: > parent_lookup = {parent['id']: parent for parent in parents} And then looped the children by looking up the parent in the list. > parent_id = child['parent_id'] It worked so in the spirit of red, green, refactor I began to refactor. First thing I decided was that the function knew too much about the data structure. Really this should be passed in. To provide maximum control I decided to provide a lambda. I refactored in steps (extract variable, variable to parameter etc.) Now I ended up with a function which looked like this: nest_children(parents, children, lambda p: p['id'], lambda c: c['parent_id']) Test passed. Job done. Not quite so fast! Look what just happened. The signature reflects the algorithm. Do you see? I'm passing two lambdas because that's how the algorithm works. This is what happens when we drive design based on implementation. I needed to stop and think again what my test should look like from a client perspective. And then make the test pass with the right algorithm. Once I thought about it, a much neater and more idiomatic function would follow the style of map: > nest_children(myfunc, parents, children) or: > nest_children(lambda p, c: p['id'] == c['parent-id'], parents, children) Now I have to change my algorithm (or GenAI does) to pass the test. See the difference testing from the outside makes to your design?

1

5 Comments

The latest version of Node is now available. Node.js 22 Some of the newest updates include: - V8 JavaScript engine updated to 12.4 - Support for require()ing ESM graphs is now exposed by default - Package authors can now easily allow both CJS and ESM users to consume their package - Added WebSocket client  - node --watch now stable - (A mode in which you can run your node server and it will reload when a change happens to the specified file or path. - Increased the default highWaterMark for streams, providing a performance boost across the board at the cost of slightly higher memory usage. What are your thoughts on the latest Node release and what features would you like to see next? #node #node22 #softwaredevelopment

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

You'd think that after 15+ years I'd be safe from null reference exceptions... Null always comes back to bite though! I was working in my ASP NET Core app and had written a method signature that allowed nulls to be returned. I was using a custom result type that allowed for the result value (or null) or an exception to come back. However, the calling code that I wrote never had any handling for null to come back! Guess what happened? Boom. We can never be *too* careful around null! 👇Check the comments for the full video!👇 ---- 🎬 Check out Dev Leader on YouTube for multiple full-length videos weekly! 🗣️ Share with your network! #CSharp #ASPNet #ASPNETCore #DotNet

21

23 Comments

TDD claim: I don't know that it's 100% true. But true isn't the same as useful. As a start point, this is the easiest way that's helped me think And better ... the easiest way to help noobs in TDD think. TDD effectiveness is ROUGHLY inversely proportional to the time-delta between load-bearing test-runs. 20 minutes between useful test runs is on the order of 5% as useful as 1 minute between useful test runs. Running tests without checking anything doesn't count.

1

Developers – good luck getting promoted if you: - build features that don’t relate to any OKRs, - write documentation for internal tools that no one uses, - spend resources optimizing a system without any traffic, or - refactor working code because it’s not written in your preferred style. Prioritization of effort is the highest leverage skill you can learn as a SWE. Your company doesn’t care if that shiny new tech stack is trendy. Only whether it will help you solve real problems for your customers. What good is fashioning a bigger mainsail if you’re headed off course because of a broken wheel?

218

59 Comments