One of the changes that has happened with Windows in recent years is the concept of forced updates. Basically, you're going to get updates from now on, like it or not. Generally that's a good thing. You can delay them for a little while but not for that long. In the Advanced options update Updates, you can see this:
So you aren't going to delay them for that long.
Now what does this have to do with tempdb I hear you ask?
Well, tempdb gets recreated each time SQL Server starts, and that's normally in two situations:
You shutdown and restart the computer that it's installed on
You restart the SQL Server service
Now Windows 10 out of the box changes that behavior. If you shut it down, and start it up again, you'll find that objects that you had in tempdb are still there. That's because a shutdown and power up are no longer the same as a restart. Choosing shutdown actually hibernates the computer and power up just brings it back from hibernation.
So SQL Server didn't get restarted.
I generally find this when I go to create a demo table in tempdb, just after restarting my machine, only to find the table is already there.
You can change that by this setting in the power options for Windows 10:
Note that I've chosen to not have fast start-up enabled. When you turn it off, shutting down actually does a shutdown.
OK, so we can see how this affects SQL Server, but what does it have to do with forced updates?
Well it's because after Microsoft applies a forced update, I keep finding settings like this "automagically" reset for me, back to the value that I didn't want. I really wish they would not do this.
There is an old saying about not reinventing the wheel yet this is something that I see happening at client sites every day. I see two main reasons why this happens:
There are so many tools and frameworks in this industry, that you can't be expected to know them all. I remember when I worked a lot with the .NET framework. I'd go into client sites and see them designing and building classes that were already in the framework. Worse, the framework classes were usually very well designed and tested.
The challenge was that with thousands and thousands of classes (at release I think .NET was over 6,000 classes), it's hard to know what's in there.
I see developers working with SQL Server and creating tables to hold queues. A table seems the natural way to store queue data but the problem is that it doesn't have many of the semantics that are needed for a great queue.
When I describe Service Broker, the developers are often very surprised to learn that SQL Server already contains a fully transactional queue, already there, right in the database. Often it has all the capabilities that they are trying to implement themselves.
More importantly, Service Broker includes support for things they hadn't even considered. Building a queue sounds simple, but it really isn't.
For example, if you take an entry off the queue, try to apply it, and the transaction rolls back, what happens next? Does your application just stop? Does it try to take the entry off the queue and apply it, only to go bang again?
The biggest problem I've seen with Service Broker is that Microsoft promoted it to database people, as it was part of the database. That's completely the wrong target market. It should have been promoted to developer leads and technical architects. I think the marketing for this was completely misdirected.
Not Invented Here
The other common reason that I come across is the "Not Invented Here" syndrome. There are clients who simply won't ever use code that someone else has created. They are usually concerned about one of these:
Takes too long to learn
Won't do exactly what I want
Don't want a dependency on it
I can't always dismiss this but I do note that the same people won't write their own database management systems or operating systems. (Although I think many of them would prefer to if they had time)
The problem with this is that the outcome for their own clients is usually substandard, and worse, their products are likely to become noncompetitive.
For example, you can write your own reporting system and/or dashboard system, but you'll probably get a better outcome if you use Reporting Services and/or Power BI. I've seen some of my own clients write their own reporting systems, but they are extremely low-functioning, and are generally unable to be integrated with any other tools that their customers use.
When you are starting to create new functionality, at least please consider that what you're after might already exist, and in a better form than you would ever have time or experience to create.
Many of my customers are software houses (ISVs). In almost all of them, I hear people complaining that they can't find enough good staff. I think they are trying to tackle the wrong problem.
Most of the staff members they are trying to find are developers, and there are so many great developers out there, but you have to accept that they might not be in the location that you hope they're in.
I've seen companies struggling to hire the last remaining developers for various technologies, from those available in that city. This often even leads to crazy situations like hiring staff that they have previously rejected. They should not be drilling further and further down the talent pool in their location.
Worse, the more that companies hire poorly qualified staff, the more their experienced staff will be spending their times fixing issues caused by staff that should never have been hired in the first place. This is a formula for losing your best staff.
Some temporary respite might come from convincing people to move to the same city, but that's a very limited group of people who can do that or will be willing to do that.
So many jobs are now able to be performed from distributed locations, and development jobs are prime examples of these.
Why hire poorly qualified locals at ever-increasing costs when there are many outstanding people in other locations?
Instead of trying to fight for the last remaining staff in a city, and paying ever increasing salaries to ever less capable staff, companies should make a serious commitment to enabling remote work, and investing in really high quality communications infrastructure and probably some software. It's important to get out of the mindset of needing to have all your staff in your building.
It's time to look outside. It's a big world out there, full of amazing people who could be doing great work for you.
A current trend that I can't say that I love is constant churn within software applications. I have no interest to go back to the days where we got a new version of SQL Server or Power BI, etc. every few years.
In fact, I thrive on change. However, I've now become really concerned about how anyone:
Learns to use a complex application
Remembers how to use a complex application when they don't use it daily
I first really struck this issue with Azure. If I was teaching a class that used Azure, I could check every single lab on Sunday night, then Monday morning, the students would find it had all changed. That's OK for an experienced person, but not OK for a learner.
I love the rate of change for Power BI. We're endlessly getting wonderful new things. But I have to say that every class that I teach on this is like a new experience. I've got another one this coming Tuesday. I used to look forward to them but now I have a major hesitation every time, as I wonder what parts of the labs will have broken.
This is now an ongoing challenge for all this type of software though. I helped create some labs for VSTS very recently, and when I look at the product now, it barely resembles the one that I built the labs on.
Is it better? Probably yes.
But even though it might have been a few months ago, it feels like just the other week, and yet, not only has the UI changed, entire concepts have been added or removed, and the order that things are done in has changed substantially.
I don't know the answer to this but the current rate of churn is a substantial issue.
I gather the plan with the DevOps guys is to put a set of labs on GitHub, and let people who are doing the labs point out the issues day by day as they strike them. Again, for experienced users that might work. But for newcomers, I really wonder if that's what they'll think.
Will they realize the app must have changed, and it's all different, or will they just think the product is too hard to use. Either way, they'll be very frustrated.
And while initial learning the product is one thing, I'm worried about it longer-term. A product like VSTS lets you set up automation and you hope you won't need to change it constantly. But if every time you go to make a change, you're struggling to use it like you're a newbie again, that's a problem.
Finally, I'm really concerned about ongoing support.
The vast majority of support of software applications today happens from community resources like blogs, webcasts, etc.
Will they continue to be created at the same pace if the authors know they'll be irrelevant or wrong within a very short time? How will end-users learn to do things when none of the online examples they find still work?
I've concluded that many software vendors (particularly large ones) don't understand how much support users of their software provide to each other, and how critical that support is.
The SQL and data communities are a good example of this. When someone has a problem and are wondering how to solve it, they don't call Microsoft or Google or Oracle (or whichever vendor) first. If they're lucky, they ask a colleague for help. But most will simply make a Google search (or yes a Bing search) to try to find an answer.
No matter how obscure an error message might be, if someone else has struggled with it before, at least there's a chance that on an online forum, someone will have spelled out what caused it for them.
Even cryptic values like app IDs in Windows that look like this:
can be matched to an error or an application that's causing the error.
Most of this happens without the vendor even being involved.
So one of my pet hates (which Microsoft have heard loud and clear on internal mailing lists) is applications that break this pattern.
Every time I have an error that says:
and nothing else, I want to scream. Even that's enough to get an answer sometimes. "Every time I click on XXX and drag the YYY, I get an error saying Oops. Something went wrong!" might lead to a posting that solves the issue but it's so much tougher when there's no other info.
A plea to developers:
At the time the error occurs, even if you don't know exactly what happened, you must know something about what you expected and what happened. Tell us something. No matter how cryptic.
Another related trend is where there is an error message but it's a GUID:
And we think: "Great. We have something to work with" only to find that the GUID changes every time the error occurs and is only meaningful to the support team at the vendor organization.
Please don't do this either.
Give us something repeatable that we can use to help each other.
Digital Transformation and Cloud Transformation are phrases that I hear bandied around at nearly every large organization that I currently doing consulting work for.
Yet, in so many cases, I can't see the organization achieving the changes required. This is for two core reasons:
The first is that the culture within the organizations is a major hurdle. There just isn't enough flexibility to think outside the box about alternative ways to work.
Worse (and probably more concerning), I see these companies taking advice on how to make these transformations from companies who don't themselves "get it".
An organization that is cloud-antagonistic internally, and stuck in an endless IT management quagmire, isn't likely to make a good cloud transformation, and they're certainly not going to be a successful partner to be able to help you to make a successful cloud migration or to implement a cloud transformation within your company.
An organization that doesn't use business intelligence (BI) or analytics internally isn't going to be able to help you make that transition either.
If the organization is claiming to be proficient in an area of technology, ask them about the use that they are making themselves of those same technologies. As a simple example, ask them about their internal analytics that they can see on their own phones.
To be any good at any of these areas of technology, companies need to live and breathe them daily. If they don't, find someone to help you who does.
When many SQL Server customers are asked why they haven't kept up to date with either SQL Server versions, or more importantly, patches to SQL Server, the answers usually boil down to two reasons:
They are just slack
Their vendors won't support the later version or patch level
Many SQL Server application vendors don't keep up to date with testing of their applications on released versions or patches for SQL Server.
While I can understand a hesitation to quickly support later versions of the product, refusing to support later patches of supported versions is particularly concerning. Worse, actively telling customers to avoid installing security patches is deeply troubling.
Preventing clients from installing security patches is simply not reasonable.
If there is a proven issue with a patch, that's understandable. But if the main reason is that the vendor just hasn't done the work to test the patch, I believe that vendors who do this need to bear liability for any ensuing issues that occur, regardless of their license agreement that might try to exclude consequential damages from use or inability to use their products.
I've recently been working at a site at present where a new case-sensitive SQL Server system is being implemented. I cannot begin to describe what a poor idea I think this is.
In the end, all that a case sensitive system allows you to do is to have:
Multiple identifiers exist
They exist in the same scope
The names of the identifiers differ only by case
You'd have a hard time convincing me that that would ever be a good idea.
At least not for a system used by typical humans. No sensible person is ever going to be comfortable with "John Smith" being a different name to "john smith". And similarly, do you really want a single database table with a CustomerID column, a CustomerId column, and a customerID column?
Well I certainly don't.
In the new system that I mentioned, there are columns ending in ID, Id, etc. They haven't even been consistent in the naming of their case-sensitive objects.
And yes, I hear the "but what about private variables vs properties in languages like C#?" complaint:
Age is the object's property
age is where the object stores the value assigned to the property
Surely we can come up with a better naming convention than that. I've lost count of how many times I've seen people using the property when they meant the private variable or vice versa. It's just not sensible.
Now before I hear complaints that case matters, be clear that I'm not talking about case preservation; that's an entirely different thing. Yes, if I defined a column as CustomerName, I don't care if I query it by customername, Customername, etc. I want it coming back as CustomerName ie: however I defined it. Case preservation is a virtue; it's case sensitivity that I see as an almost always painful and unnecessary thing.
Worse, if you've ever tested an application against a case-sensitive server, you'll understand the challenges involved. It's hard to get case-sensitive code correct.
I gather that SQL Server Management Studio has a current bug that arises when you remove and re-add a database from an availability group on a case-sensitive server. Why? It appears that they aliased a table with A in one place, and used the alias as a in another place. It's really nonsense to have a situation where that matters but it highlights the other big issue. It makes for fragile applications.
Do you really want to be the one who's testing all your applications and 3rd party utilities to find out if they've tested case-sensitivity properly? Do the tools that you use have a better testing regime than SSMS? I'll bet that most don't. And what that means is that you get to spend your life wading through obscure tooling issues.