11 ms·
(The 80/20 rule applies below, some developers do care) Developers... just don't care. They want to spin up an ORM, point it at a URI, and forget about it. I'
by falcolas 7y ago
(The 80/20 rule applies below, some developers do care)
Developers... just don't care. They want to spin up an ORM, point it at a URI, and forget about it.
I've fought this for over a decade now as a DBA, SRE, DevOps, and architect. Most of the developers don't want to deal with anything infrastructure-wise; they want to spend all the time they can just focusing on the problem they're writing software to solve.
Observeability, reliability, scalability - these are all words that are translated into either "someone else's problem" or "unproductive busywork" in their minds.
- throwaway13337 7y agoAll of those things are unproductive until after your project is successful which is usually not a guarantee when building the software. You're not gonna need it.
- hobs 7y agoObserveability, reliability, scalability - really easy to bolt on once you are successful. There's a middle ground, and a DBA turned SRE turned Architect is probably ok with compromises, those are all roles where "it depends" is a bylaw.
- falcolas 7y agoSo, they really aren't that easy to bolt on, if not considered from the beginning. Monoliths, for example, are a real PITA to make reliable and scalable. Worse, once your company is successful, there will be an endless list of features to add to your product, meaning nobody has the time to "bolt those features on". How the product begins, is how the product often lives on well past it's expected lifespan.
- hobs 7y agoMy apologies that the sarcasm was a bit too subtle - no they are not.
- aeyes 7y agoHow is scalability easy to bolt on? Most companies end up rewriting their entires stack, multiple times.
- AndrewKemendo 7y agoThose are absolutely not easy to bolt on.
- ric2b 7y agoAnd security, that one's trivial. Just get an audit and fix whatever they manage to find, done!
- rietta 7y agoI sometimes feel in the minority. I love databases. When I work in the Ruby on Rails ORM ActiveRecord I can actually visualize the SQL it is generating in my head and also do all sorts of tricks when needed.
- petepete 7y agoThat's the key. ORMs get a bad name but most of the time you just want to display a list of things, or one thing in more depth or maybe create a new thing. ORMs unfortunately, have a habit of getting in the way when you want to do something they don't natively support. When they just ignore things the database provides people just end up reinventing the wheel. Rails' implementation of enums is a good example of this.
- lovegoblin 7y ago> Rails' implementation of enums is a good example of this. The advantage of ActiveRecord enums (vs db-native) is that you can change the list of valid values without having to run a whole ALTER TYPE - and all the overhead that would entail in doing without downtime in a production db.
- petepete 7y agoAnd the disadvantage is that you need to look at the code to understand the data. Some things change infrequently enough for DB native to be the better solution.
- evsasse 7y agoA nice "trick" is to declare your enum column on the database as a string, and your enum in the code as a hash with string values. So you can have self-explained data saved onto the database, and all the niceties Rails gives you from the enum. enum object_type: { review: "review", purchase: "purchase", offer: "offer", reward: "reward" } # OR enum action: TYPES.map { |type| [type.to_sym, type.to_s] }.to_h
- FpUser 7y agoadd to that "do not want to declare/worry about types", "cant be bothered about RAM usage/cache coherency/etc", "concurrency" etc. etc. All of those are "premature optimizations".
- yjftsjthsd-h 7y ago> All of those are "premature optimizations". And they are, until they aren't. And I really do mean that in both directions: Much of the time, the simplest, dumbest, most naive solution is 100% fine for realistic load for the forseeable future. And then some of the time it breaks terribly and you do need to spend effort optimizing it, whatever that entails.
- FpUser 7y agoTo be clear I am not advocating optimizing everything down to the last bit here. Problem here is when THERE IS a need many would not even have a slightest clue where to begin as all those "low level" concepts were relegated into oblivion.
- hinkley 7y agoThe question rarely asked is, "Can your team go from zero to sixty on this sort of thing when this happens?" Technically optimizing as you go might be a 'waste' of time, until it isn't, because your team can handle a serious performance problem in days instead of months (or IME, never).
- davedx 7y agoAs a developer: I do care, but it's hard for me to focus on building software if I also need to think about DBA tasks, DevOps tasks, and so on. These things all take time, patience, and energy. I've just spent most of today running and re-running a CloudFormation template to create a SQL database. Most. Of. A. Day. It's partly because I'm not a DevOps expert and even if I wanted to be one, that would also take time, patience and energy. There's a reason people have specializations...
- cookiecaper 7y ago> It's partly because I'm not a DevOps expert and even if I wanted to be one, that would also take time, patience and energy. It's this exact divergence that creates the disconnect. If someone doesn't understand and doesn't have to care about the whole experience, they're going to focus on their side and stop when their side is good enough. On the other hand, if that same someone is going to be regularly developing the application, making changes to the database, and triggering deployments, they will find a way to make the process flow. They'll make it adaptable enough that it's not a day-long pain any time they need to run a migration or spin up a test DB. The whole toolkit can and should be available because every piece of the stack opens up new possibilities. You want, and at least at some level, can have, people who know this well enough to make good use of it. Nitpicking over "not my specialization" is the antithesis of a smooth engineering process.
- davedx 7y ago> Nitpicking over "not my specialization" is the antithesis of a smooth engineering process. Counter argument: jack of all trades, master of none. I'm already a full stack developer. I work on a complex front end application, a GraphQL server, a .net core platform split into multiple microservices, and a MSSQL database. I know my way around these components fairly well now but it's taken a good couple of years to get to this point. I could also invest a bunch of my time learning all the intricacies of cloudformation templates and how IAM roles work too, sure. But is it the best use of my time as a developer, when I'm much more productive writing code? You can just end up stretched too thin.
- balls187 7y agoProbably because they don't need to think about those things. I started my career as an Embedded Software Engineer, and memory allocation, and clock cycles hand to be managed. Our software ran on systems with limited memory, and had to fit in one 60hz cycle. We supported VAX system that used VAX Floating point, and had to be cognizant of both floating point conversions AND endian byte encoding. These days, such concepts are basically just trivia answers for interview questions. I had to think about those things because it was required. System software would crash, and debugging it on an expensive government flight sim 1000 miles away was impossible. Perhaps for the developers you work with, they don't need to think about those things because they're not required to. After all they have access to a dedicated DBA/SRE/DevOps/Architect guru.
- ffdjjjffjj 7y agoYou’d be surprised how much rank and file developers can care about observability and reliability. The key to unlocking this is making them responsible for how their code runs in production by adding them to the on call schedule.
- vsareto 7y agoToo bad there isn't an equivalent on-call punishment for management and others around the dev process who also make mistakes and bad decisions. As far as I can tell, they get paid more for doing less.
- vajrabum 7y agoI'd guess that problem might go away if you make their bonuses contingent on a sleep numbers (along with the SLAs) for whoever has to run the application or it's downstreams whether that's a dev or an ops type. Base the number on pagerduty calls or something like so they can't game the number.
- edraferi 7y agoThat is a wonderful idea. Managers are responsible for the performance of their teams. NOBODY wants to sandbag sleep numbers, so it'd be a decent comp metric.
- jl6 7y agoApplication developers don’t care about data - they want the database to be a dumb storage unit because they only care about their application functionality. If you can convince your application developers of the prime importance of data, they will start caring about their database. Applications come and go but data lives forever.
- jordache 7y ago>Observeability, reliability, scalability - these are all words that are translated into either "someone else's problem" or "unproductive busywork" in their minds. hence why you work in a team.. everyone provide their domain expertise.. we don't need dba to be dictating FE devs on strategies for immutable state management in the UI.
- testnew2 7y agoI don’t care and that’s why I use raw sql lol. I don’t want to learn some orm bs
- hermitdev 7y agoNot meaning to come off as trite, but I know my response will sound like I am. But, what you described is exactly why senior devs/engineers make 2x, 3x, 4x a junior. Seniors make more because they have that extra knowledge you're talking about that can take a decade or more to accumulate. The idiosyncrasies between different DBMS or even languages or even specific versions of languages. That knowledge doesn't come cheap. It literally takes upon years to develop. This is partially why I think bootcamps are bullshit. I'm sorry, but there is no way to become a competent full-stack developer, especially if you're not targeting web/browser. Give me someone with 3 months of bootcamp C++, I'd be surprised if they can get a nontrivial program to link, let alone compile.
- hinkley 7y agoDevelopers... are punished for caring. Stubborn people like me keep doing the right thing, but the fact is that there are kudos and recognition for implementing a new feature. There is nothing for keeping servers from crashing, and only a little for reducing server count if you wait for things to get bad first. The problem with doing things right the first time is nobody appreciates how hard it was. And you will sometimes get questioned about your loyalty and your competence to do the job.
- jiggawatts 7y agoThis kind of "top-to-bottom" architecture approach reminds me of Apple. They have this notion that you can't provide a good product if you control only the software or only the hardware. You need full control of both, designing in the synergies to produce a really top-notch outcome. If you read the blogs by large shops like Google, CloudFlare, or Facebook, they do the same thing on the server side. They design the software for the failure modes of the hardware, and conversely the hardware is designed to be low cost in full knowledge that the software can tolerate high failure rates. Why am I talking about hardware? Because in a typical n-Tier design, "The Database" is just one of the pancake layers between the metal and the Internet. Every layer matters, and every layer interacts with the others. Hearing developers call themselves "full stack" is hilarious to me. They're basically saying that they know 2 out of about 20 layers! Do they know about load balancing persistence? The security tradeoffs made by TLS 1.3 zero-RTT? Cache-control headers? Disk latencies? Automatic scale-out? Virtual machine affinity and anti-affinity rules? Backup and restore? Etc... The original post about how various databases treat transaction isolation modes is a tiny, tiny fraction of what a typical developer ought to know about the "layers below the web server" but likely doesn't. For example, about 50-70% of bespoke software I've seen in the wild either doesn't use database indexes at all, or uses them ineffectively. About 80% of websites either do not use cache-control headers, or if they do, they'll often end up with front-end errors due to the caching layers violating the consistency of data coming in from the database. Sure, it's a maxim of the industry that cache invalidation is hard, but there are workarounds such as constructing URLs based on the content hash. All of the fancy transaction isolation modes, to me, is wishful thinking. Get more developers to use indexes first, and then come back and teach them the esoteric stuff after that!
- ivanhoe 7y agoFor those devs the solution is that DBAs provide stored procedures and predefined views and block them from accessing anything else. Or address it on the app level, have someone knowledgeable create repositories with all the queries, and mandate the rest of team to stick to using only these predefined methods. Either way, people who don't care about infrastructure should have their access to that infrastructure maximally limited and wrapped in safety nets. For both sides to sleep better.
- masswerk 7y agoThere's truth to this, but there are also reasons for this. First, it may be fair to say that infrastructure is in an other domain of problem solving than structuring and implementing program logic. (Speed requirements and crunch time tend to lock a person in a single domain.) Second, those developers, who do understand the importance of infrastructure, tend quite naturally to care for those levels which are closer to them and which they actually may understand (like the programming language and how it actually implements things, standard libraries, dedicated libraries, the OS, any middleware). Finally, SQL via networks (and all the flavors this may come in) is hard, there's a reason for why there are specialists. Speed of development, of course, is orthogonal to concerns about infrastructure. Which may be a major concern. Communication (a constant source of enterprise horror stories) and general awareness (on all levels) may help. These are not problems that can be solved on a single side of the implementation. And then, there's certainly some kind of "developer heroism", which doesn't especially help. (I guess, I've successfully managed to have messed up with everyone? ;-) )
- chaostheory 7y ago> Observeability, reliability, scalability - these are all words that are translated into either "someone else's problem" or "unproductive busywork" in their minds. The root of the problem is the same reason why Google keeps creating completely brand new applications instead of just maintaining and improving their existing ones. Maintenance is not rewarded. Anything existing is not rewarded. Management only focuses on new customers brought in by new features or product asap. Management doesn't care about maintenance; they care about growth, so developers have no real interest in it. Words tend to be empty. If you want to see how maintenance is really valued, look at the company's promotion system.
- pjmlp 7y agoDepends on the organization. Thankfully in most places I have worked so far you wouldn't go very far being an 'X Developer'. Everyone has always been required to be an expert in at least two domains, those T and Pi shaped concepts. So I have very seldom met those kind of devs that only want to spin up an ORM.
- arvinsim 7y agoPerhaps development work has reached complexity where it demands full-time attention? Perhaps there is a reason why DBA, SRE, Devops and Architects are separate roles?
- commandlinefan 7y agoWhat, you're not a full-stack rockstar ninja?
- mgkimsal 7y agoIn either case, someone needs to have moderate expertise in multiple areas of tech. If it's wrapped up in one person, the business needs backups to deal with the bus factor. If it's spread across multiple people, you now need to be selecting for people with moderate tech expertise AND the ability to communicate and work together with other people effectively. And you need someone to manage their process (in some manner - doesn't necessarily mean micromanaging). So the 'full-stack rockstar', if they have good communication skills, can exist and be valuable, but still isn't the best long term solution for a business of any size.
- falcolas 7y agoA DBA can't fix a developer's code. A good 3/4 of the list linked in TFA are things a DBA or Architect can't affect. At some point, a developer needs to be responsible for how they use a tool that's been provided for them. Abstractions break.
- gedy 7y agoWell likewise, many of the DBAs I've worked with don't try and understand the software needs, and want the world to revolve around what is optimal for them.
- cookiecaper 7y ago> Perhaps there is a reason why DBA, SRE, Devops and Architects are separate roles? It's mainly an artifact of the way we've broken up degree tracks, and the boundaries that each group is taught to stay inside, lest any particular group actually ends up culpable for a failure. Make fun of the "full-stack rockstar ninja" all you want, but the reality is that it is possible to have a functional understanding of all of these areas. It's just a matter of having the confidence and doing the legwork. To the extent that more of your people have a working knowledge of these domains, you'll not only have a better end product, but a much easier time getting stuff done. There's room for hyper-specialized expert consultants in each field, of course, but the myth of the myth of the full-stack developer exists primarily for political convenience. Most of this stuff is not any harder than the rest of it, and can be learned by anyone willing to sit down and learn it.
- vsareto 7y agoMany interests are pulling developers' attention in several different areas all the time. Database, security, accessibility, performance, infrastructure, tooling and productivity, business concerns, workflow processes (agile), language concerns, new things All of these like to say "if only the developer could do $MY_AREA better, they'd be better developers and we'd have better software". Each of them wants to pile on more requirements for what devs ought to know. Let's say we agree that devs should know all of these things. After you tally up every area's demand, you're probably looking at a 10 year timeline before someone's decent in all of these areas by spending approx. 1 year on each of these areas doing meaningful work (as opposed to contrived tutorials). Even then, things change constantly, so you'd have to continually practice all of these things. Who knows if we'll add a new category next year? Then it becomes an 11 year timeline. At some point, developer responsibility has to stop.
- harikb 7y agoNot really. That is exactly the point the article is trying to make. Developers need to care about these things - _enough to know who to go get help from_. That is the minimum. Also 10 years is an exaggeration. 2 years working on a non-trivial backend should expose one to these problems. From what I have seen, products built without caring about these will usually get rebuilt a year from the original release - either by the same company or by a competitor who killed them.
- mgkimsal 7y ago> 2 years working on a non-trivial backend should expose one to these problems. You can be exposed to them, but without understanding them, and experiencing both good, bad, and really bad 'solutions' to them, and understand the impact (on the business, on the code, on security, on maintainability, etc)... you just can't really get all that in 2 years. I know plenty of people who've been 'exposed' to certain type of tech problems, and the solutions they decide on are objectively really bad for any metric other than "stop this error from showing up on the screen right now". I've been doing this for a bit over 25 years, professionally now, and... there's a lot I don't 'get' with current stuff. But I've seen and lived enough projects, in enough different situations, to have a good idea of impact of tech decisions, and to understand how to make tradeoff decisions. I had someone call me up to 'fix' a problem in a system I'd given then 15 years earlier. It was still running, more or less the same, and... spelunking your own code 15 years later gives you a new perspective on the impact and value of decisions you make. Many of the things people get hung up on (code style, tabs/spaces/etc, particular naming conventions, etc) provide pretty much no value in digging in to old code that no one has touched or thought about in a decade. Correct comments, sample data, repeatable tests hold so much more value, but are harder to get people to commit to following through on.