How To Connect To SQL Server From Another Computer On Your Local Area Network

Okay, so you've got SQL Server installed and you've been happily building away - on the server itself. But in the real world, you need to connect from another machine on your network. That's where the fun (and, let's be honest, a little bit of chaos) begins. Most of you aren't going to work directly on the server; that thing's going to be stuffed in a corner doing its thing while you and your users connect from your workstations. Today we're tackling how to set up SQL Server for remote connection, what to check when it inevitably doesn't work, and how to troubleshoot so you're not pulling your hair out wondering why SQL Server is giving you the cold shoulder.

Let's dive right in. Most small offices these days are already used to the "split database" setup, using Microsoft Access or similar. If you've got file sharing set up, and you can browse shared folders between your server and your PC, you're halfway there. This is important - not because SQL Server needs file sharing to work, but because if your machines can see each other, it means your network permissions and authentication are in place. Think of sharing a folder as a basic "connectivity test" before you start with SQL Server itself.

By default, SQL Server Express is locked down big time for remote connections - right out of the box, it'll only allow local connections until you say otherwise. So let's walk through what needs to get flipped and poked to open up your server to the network.

First up, make sure SQL Server is actually running and that you can connect to it locally using something like SQL Server Management Studio (SSMS). Obvious, I know, but it's the #1 "duh!" moment that keeps people up at night.

Now, crack open the SQL Server Configuration Manager (search for "config" in Start if you don't know where it is). Pin it to your taskbar - you'll be using this a lot until you're through setup. In there, expand the SQL Server Network Configuration (ignore the 32-bit one!), then find the right instance (like "Protocols for SQLEXPRESS"). Look for TCP/IP. Bet you a donut it's disabled. Right-click and enable it. But - here's the kicker - the change doesn't take effect until you restart the SQL Server service. So, hop over to "SQL Server Services," right-click your server, and give it a restart.

Next, fire up the SQL Server Browser Service. This handy little background service helps workstations find your server by name over the network. It often defaults to "stopped" for security. Set its Start Mode to "Automatic" and start it up. Again, if you're in a high-security environment, you might want to leave this off, but for most folks, just enable the thing. Restart the SQL Server service again as needed so your changes stick.

After that, check your Windows Network Profile - make sure your server is on a Private network, not Public. Private means silly devices like your coworkers' laptops are allowed to see you. Public is for airports, coffee shops, and anyone paranoid about hackers. Set it right in your network settings or you'll be chasing your tail when connections fail for no apparent reason.

Now, authentication. We're enabling "Mixed Mode," which lets you use both Windows Authentication (where access is based on Windows user accounts) AND SQL Server Authentication (which uses usernames and passwords stored within SQL Server itself). Windows Authentication is perfect if your network is already humming with local user accounts that match between server and workstation. If you want to avoid potential headaches with mismatched logons or if you're connecting over the internet, SQL Authentication will likely be your friend. Head into SSMS, right-click your server, and under Properties > Security, flip the server authentication setting to "SQL Server and Windows Authentication mode." You'll need to restart the server again for this to take effect.

Creating logins is next. In SSMS, drill down under Security to Logins. Here you can add SQL Authenticated users (specify a username and password) - and choose what each one can do. Go to "User Mapping" and assign permissions by database. If a user needs full design access (like you), give 'em db_owner. If it's a standard user, just assign db_datareader and db_datawriter - they can interact with data but not wreck your carefully-crafted table designs. Repeat as needed for different users or permission levels.

At this point, you might be tempted to try connecting from your workstation. Sometimes, when browsing the network for available servers in SSMS, nothing shows up. Don't panic. That "browse" feature is notoriously unreliable (and seasoned SQL pros ignore it entirely). Instead, try connecting by directly entering your server's IP address. Not sure what it is? From your workstation, run a command prompt and type ping [server name] (e.g., ping Kirk). Or, go to the server, open a command prompt, and type ipconfig for the IPv4 address. Use that in your connection string.

If your connection just hangs, odds are the firewall is blocking you. By default, Windows Firewall says "no thank you" to incoming SQL Server connections on port 1433, which is the default. To change this, open Windows Defender Firewall with Advanced Security on the server. Add a new inbound rule to allow TCP traffic on port 1433. Be sure to make it active for your Domain and Private profiles - not Public. Give the rule a friendly name so you remember what it is later. Once you've done this, close the firewall window and try connecting again. If all is well, your connection should go through instantly.

Bonus tip: for smoother connections long-term, consider setting a static IP address on your SQL Server box. That way you won't have to chase it around the network every time it reboots and gets a new IP lease.

If you're doing Windows Authentication, make sure the accounts your users log in with exist on both the workstation and the server, with matching usernames and passwords (unless you're on a domain, in which case things are slightly less crazy). It's easiest to add the user on the server, set the permissions in SSMS, and then just log in to the workstation with the same account. If you're running a small network and folks log in with Microsoft accounts (the kind with an email), you might run into authentication snags - SQL Server isn't always thrilled to work with those on peer-to-peer networks. In that case, SQL Authentications might just save your sanity.

If you've followed all these steps in order - server running, TCP/IP enabled, Browser Service running, network profile set to Private, authentication modes set, users created and mapped, firewall port open - you should be in business to connect from your workstation. If not? Time to consult your IT wizard, or at least post in the forums so we can commiserate together. And if you're still stuck, there's always my file-sharing video or a future deep dive into Windows networking (let me know if that would save you from more headaches).

That's the rundown for getting SQL Server connected from another machine on your network. If you got it working, high five yourself! If not, review the steps, pay special attention to TCP/IP and firewall stuff, and don't be afraid to reach out for help. For the full walkthrough, just watch the video embedded above - sometimes seeing it on screen does wonders for troubleshooting.

Live long and prosper,
RR

How To Create An Update Field VBA Helper Function In Microsoft Access

Tired of clicking and navigating through forms or slogging through loads of code just to update a simple value in your table? If you're managing a Microsoft Access database and you find yourself constantly opening forms or repeating long record set code to change a single field, it's time for a smarter approach. Today, I'll walk you through how to build a versatile VBA helper function that lets you update any field, in any table, with one quick line of code. No more messy SQL, dealing with quotes and date formats, or wasting time on "boilerplate" record set procedures. Sound good? Let's dive in.

Imagine this scenario: way back when, I built a database to track orders for my business. Over the years, it grew like a Christmas tree - bulbs and wires running everywhere! At one point, I was opening forms all over the place just to automate little updates: pop open the customer form, change a value, close it again. It worked, but it's sloppy and inefficient. As any long-term Access developer will tell you, relying on open forms for automation is a recipe for frustration and bugs, especially as your database (and ambitions) grow. That's why I eventually realized the smart move is to handle simple updates purely in VBA behind the scenes, no forms required.

When you need to update a field in Access, you've basically got three options: write a custom SQL update statement, wrangle with record sets, or (now!) use a reusable update helper function. Sure, SQL is fast and efficient, but it gets messy fast when you're concatenating strings, worrying about punctuation, date formatting, and handling null values. Plus, one little typo can blow up the whole thing. Record sets are more flexible but, honestly, if you just want to change one measly field, the six or ten lines of code needed are just a hassle. Multiply that by dozens - or hundreds - of times across your database and it quickly becomes a nightmare of copy-and-paste repetitiveness.

Instead, let's build a helper subroutine, living in your global module, that standardizes this entire process. The goal: quick, reliable updates with minimal fuss. Here's the approach - no code here, but I'll outline how it works so you can implement it yourself (detailed code is in the video if you want to see every step).

You'll want your helper to accept four key pieces of information: the table name (as a string, like "customerT"), the WHERE condition (also a string, like "customerID = 4"), the field name you want to modify, and the new value. Here's the beauty: by making the new value a 'variant', the helper can accept anything - string, date, number, even null. No more worrying if you're passing the right type.

Within the helper, you'll open a record set against your chosen table, using a SELECT * (the star means "all fields"). Unless you're worried about needing maximum speed on very large tables, pulling in all fields helps ensure future compatibility and prevents those "how did I forget to include that field?" moments. Pay attention here: in your SQL statement, don't forget the space before 'WHERE'! It's a classic beginner stumble - missing that space will gum up your syntax and make Access throw a fit.

Now, you'll edit the record set to set the field's new value. Instead of hard-coding a field name, you pass it as a variable - slick and flexible. After updating, save and close up shop: 'update', 'close', 'set to nothing'. And you're done! One quick call to this function will handle your update anywhere you need it, with a lot less typing and a lot fewer headaches.

Here's an example: let's say you want to set customer #6 (Malcolm Reynolds, perhaps) to have a family size of 10. Simply pass in "customerT", "customerID = 6", "familySize", and 10. Done! No record sets to fiddle with, no SQL string to compose, just a straightforward function call. Check your table - in this scenario, Malcolm's family size is now 10, and you barely broke a sweat.

Trust me, this may not seem glamorous, but if you've been battling with updating values across a complex Access database, this tiny function will save you buckets of time - and probably a few strands of hair. Not only does it clean up your code, but if you ever need to change how updates are handled (maybe to add error checking or logging), you only have to do it in one place.

Of course, a little wisdom: use this helper for those one-off or light-traffic updates. If you need to update a huge batch of records, or change 20 fields in a loop, SQL or tailored record sets are still more efficient - this helper isn't meant for heavy lifting, just quick fixes and repetitive utility calls. But as a convenience tool, it's a game-changer: less repetitive typing, fewer copy-paste errors, and no more breaking workflows every time you refactor a table or form.

If you want to expand things even further - like adding error handling for missing records, supporting multi-record updates, appending text, or safely incrementing numeric fields - be sure to check out the video above for the full walk-through and extended explanations.

The real take-home message: stop repeating yourself. Build small, reliable helper tools to handle frequent tasks and your codebase (and brain) will thank you. Save the custom SQL for where it really matters!

Questions? Comments? Tell me how you plan to use this helper, or what other headaches you've solved with little VBA shortcuts! And remember: if you want the blow-by-blow code and see it live in action, watch the video embedded above.

Live long and prosper,
RR

Way Too Late Last Night

So yesterday I decided to make what I thought would be a quick, harmless, “ten-minute improvement” to the website database. You know the kind. The little tweaks you do just to smooth things out. Streamline a process. Make it cleaner. More efficient. Cross all the i’s and dot all the t’s. Yes, I know that’s backwards. I say it that way on purpose. It’s tradition at this point.

Anyway, this particular process dates back to Ancient Richard Times. We’re talking years ago, before I knew any better. It runs a recordset loop and, as part of that loop, it actually opens up the customer form to do some work. Horrible practice by today’s standards, but it’s been surprisingly bulletproof. Maybe once a month it locks up, and my Watchdog utility steps in, restarts Access, and life goes on.

But yesterday I watched it happen and thought, “Well that’s silly. I can fix that.” No need to open a form. Just handle everything in the background with a proper recordset. Cleaner. Faster. More elegant.

Famous last words.

I rewrote it. Beautifully, I might add. Proper error handling. Nice clean logic. The kind of code you sit back and admire for a second before moving on. What I did not realize, however, was that other parts of the system were quietly depending on that form being open. Not for the main task, but for things that happened afterward.

So now this function broke that function, which broke another procedure, which triggered a cascade failure worthy of a warp core breach. At one point I seriously considered restoring from the pre-change backup and calling it a night. Crawl into bed. Pretend none of this ever happened.

But no. The perfectionist in me took the conn.

So down the rabbit hole I went. Fix this dependency. Rewrite that routine. Adjust the follow-up process. Then I discovered the user upload procedure, the one that pushes data from my local Access database to the web server, also relied on the old behavior.

That fix broke credit card processing.

Because of course it did.

Next thing I know it’s 4:00 in the morning. I’m squinting at the screen with my one good eye, testing transactions, running uploads, watching logs scroll by. I even had to switch the VBA editor into dark mode because the white background was burning a hole straight through my skull. So if you notice future videos looking a little more “night shift friendly,” that’s why.

The good news is by Monday morning everything was stable again. Systems operational. Engines back online. No customers the wiser.

But there were a couple of solid takeaways from the adventure.

First, backups are life. I had multiple. I made another one right before starting the “ten-minute fix.” At any point I could have rolled back instantly. That safety net makes deep surgery possible.

Second, it’s always the ten-minute changes. Every time you think, “I’ll knock this out before dinner,” you are lying to yourself. That is never a ten-minute change. That is a six-hour marathon wearing a fake mustache.

And the final lesson, especially for anyone doing client work, is about estimates. Never give the optimistic number. Never tell the captain it’ll take two days.

You tell him two weeks.

Because when you pull it off in five days, you look like a miracle worker. Scotty understood this. Reputation management through strategic pessimism. Don’t be Geordie giving accurate engineering timelines.

Be Scotty.

End log.

LLAP RR

Microsoft Access Day: March 27, 2026 in Redmond, Washington. Meet Access Team Members & MVPs

Attention, Access developers - here's an event you'll actually want to put on your calendar. If you're serious about Microsoft Access, whether you're building databases as your full-time gig or you're just the "Access guy" everyone in the office calls when anything needs fixing, there's something big coming up that you'll want to know about: Access Day 2026.

This isn't just another generic tech conference where you have to sit through hours of buzzword bingo and hope that someone, somewhere, mentions something relevant to Access. No, Access Day is the real deal: a one-day event, happening Friday, March 27, 2026, in the Redmond, Washington area - that's right in Microsoft's backyard. If you're within road trip range or you've been waiting for a reason to visit Seattle, this is it.

I attended Access Day previously and it's honestly some of the best time you can spend with the Access community. There's a mix of presentations, lively hallway conversations, and, best of all, actual members of the Microsoft Access team are there. They share what's coming next, answer questions, and sometimes even soak up a little developer feedback (they're good sports about it).

Sessions include starting and growing a consulting business, taking over and maintaining existing Access applications, working with Azure SQL for secure remote access, solving the "New Outlook" problem with Graph API authentication and MFA, and using AI as an Access development assistant to export objects, analyze code, and identify performance and security issues.

Of course, the Microsoft Access product team will be there giving updates and sneak peeks at what's next for Access. It's a rare chance to ask them questions directly - just try not to overwhelm them all at once.

There's even talk of an optional dinner afterward, so you can keep the geek talk rolling late into the evening. If you've ever wanted to debate DAO vs. ADO over a nice steak or just pick up a few new tricks from fellow developers, this is your crowd.

Registration is open now. I'll drop a link with the details below. If you're able to make the trip, I highly recommend it - not just for the presentations, but for all the stuff that happens in between. You'll leave with new ideas, new connections, and maybe a couple of new friends who actually want to talk about Access as much as you do.

If you want the full walk-through and all the details, check out the video above. Hope to see you there!

Live long and prosper,
RR

Access Developer 52: Building a Complete File Drop System with Previews, Launching, and Deep Linking

Managing files directly inside your Microsoft Access database doesn't have to be a clunky experience. Imagine being able to drag and drop files, preview them instantly, and launch anything - from documents to folders, web links, or even other Access databases - right from your Access form. Taking your database to this professional, super-productive level is completely doable, and it's exactly what we're tackling today.

Let's dive right into creating a file drop system that's genuinely useful. The first step is setting up the ability to click and drag any file onto a form, which isn't just a party trick - it keeps your files organized and tightly integrated. With each dropped file, you'll have Access automatically store and track it in a designated folder, all from the comfort of your database interface.

Now comes the fun part: transforming simple file storage into a user-friendly preview and launch system. The magic starts with image thumbnails and recognizable icons for common file types - Word, Excel, PDF, and so on. This lets you scan your files visually instead of decoding mysterious file names. Want to launch a file? Just click its thumbnail. Whether it's a document, a web link, a folder, or even another Access database (with custom command-line settings, no less), you're covered with one centralized interface.

But we're not stopping at just previews. Let's talk about performance. Quick previews mean no awkward waiting for giant attachments to load, even if you're dealing with folders or hyperlinks and not just traditional files. The system also gracefully supports unknown file types - so, you know, you're never stuck with the dreaded blank icon of confusion.

Automation really makes this setup shine. Integrating with Excel and Word, you'll set up routines to open a particular worksheet directly, or jump straight to a header in a Word document, or even trigger a search as soon as the file launches. This isn't just convenient - it's a major time-saver if you routinely work with large or complex documents.

So if you're interested in elevating your Access app into a full-fledged file management powerhouse, this is the way to go. It saves time, reduces errors, and just plain feels cool. If you want all the gritty details, hit play on the video above for a step-by-step walkthrough. And remember, you can always reach out via my website or comment below if you run into any snags.

Enjoy building your own next-level Access file system!

Live long and prosper,
RR

When Policy Overrides Science

This morning's reflection came to me the way many of them do. Coffee in hand. News feed scrolling. Brain booting up somewhere between "system check" and "engage warp drive." And then I hit a headline that made me stop mid-sip and just stare at the viewscreen.

The current administration has reversed the EPA's long-standing "Endangerment Finding" on greenhouse gases. In plain English, that's the official scientific determination, first made in 2009, that greenhouse gases like carbon dioxide and methane pose a danger to human health and the environment. That finding wasn't based on opinion. It wasn't based on politics. It was built on decades of atmospheric data, epidemiology, climate modeling, and peer-reviewed research. In other words... actual science.

And here's the key point that keeps echoing in my head: this isn't some unresolved debate in the scientific community anymore. Among climate scientists, the role of greenhouse gases in driving climate change is settled science. You'll always find outliers. You can find someone who thinks the Earth is flat too, but the overwhelming consensus, backed by measurable data, is clear. Greenhouse gases trap heat. Rising concentrations correlate with rising global temperatures. That warming has downstream effects on weather, oceans, agriculture, and public health.

So when a policy decision comes along and effectively says, "We're no longer recognizing that scientific conclusion," it's not just regulatory change. It feels like looking at a warp core breach alarm and deciding the computer is being dramatic.

Now, I try very hard not to turn this platform into partisan space politics. I've got students across the entire political spectrum, and that's exactly how it should be. You can believe whatever you want about taxes, spending, regulations, or the proper size of government. Reasonable people can disagree on policy outcomes all day long.

But science isn't supposed to be partisan. Science is the operating system everything else runs on.

And that's where this one sticks in my craw, because computers, databases, and software development, the stuff we do here every day, are built entirely on scientific principles. Boolean logic. Electrical engineering. Semiconductor physics. Error detection. Mathematical modeling. You don't get to vote on whether binary works. Imagine trying to run Access on "feelings" instead of structured query logic. Your SELECT statements would return whatever the server felt like giving you that day.

That's not how reality works. The scientific method is why your code compiles, your GPS knows where you are, and your backups restore when things go sideways. We test hypotheses. We gather data. We replicate results. We refine models. That process is the closest thing humanity has to a universal debugging tool.

And when I look at this EPA reversal, it doesn't feel isolated. It feels like part of a broader pattern we've seen over the years. Climate regulations rolled back or weakened. International climate agreements abandoned or sidelined. Scientific advisory panels reshuffled or reduced. Environmental monitoring and research programs cut back. Pollution and chemical exposure limits loosened in certain sectors. Public rhetoric that frames established science as optional, exaggerated, or politically motivated.

You can argue the economics of any one of those decisions. You can argue regulatory burden. You can argue industry impact. Those are valid policy conversations. But dismissing or overriding the underlying science itself? That's where it veers into "we're ignoring the sensors because we don't like the readings." On the Enterprise, if Geordi tells Picard the hull integrity is down to 20%, Picard doesn't say, "Well, let's get a second opinion from someone who doesn't believe in hull breaches." He orders repairs. Because physics doesn't negotiate.

That's really the heart of today's log. This site, this community, everything we do here, is rooted in scientific thinking. You build and test your database. You validate your inputs. You verify your outputs. You trust repeatable results over gut instinct. That mindset is what makes someone a good developer, a good troubleshooter, a good systems architect.

You don't fix bugs by ignoring error messages. You don't optimize performance by pretending metrics don't matter. And you don't advance civilization by sidelining the scientific method when it becomes politically inconvenient.

Now, I'm not saying science has all the answers and that it's perfect. It doesn't, and it's not. Science is iterative. Models improve. Data gets refined. Conclusions get updated as new evidence comes in. That's the strength of it, not the weakness. It self-corrects. It's the best thing we've got for understanding the universe and how things work.

But throwing out a 17-year scientific foundation that's only grown stronger with time? That feels less like refinement and more like unplugging the computer because you didn't like what was on the screen. At the end of the day, whether you're writing code, building databases, or piloting a starship, reality still runs on the same core engine: evidence, measurement, and reproducibility.

Ignore that engine long enough... and eventually something critical stops working.

LLAP
RR

dotnet CLI list

dotnet CLI list by Alex Hedley

from Computer Learning Zone News https://599cd.com/3784