Sr. Content Developer at Microsoft, working remotely in PA, TechBash conference organizer, former Microsoft MVP, Husband, Dad and Geek.
150509 stories
·
33 followers

30 years after Microsoft went ‘all-in’ on the internet, the tech giant’s AI strategy echoes the past

1 Share

December 7 carries historical weight well beyond the tech world, but for those who covered Microsoft in the ’90s, the date has another resonance. Thirty years ago today, Bill Gates gathered more than 200 journalists and analysts at Seattle Center to declare that the company was going “all-in” on the internet.

As managing editor for Microsoft Magazine at the time, I was there, and I remember it well. Three decades later, I can’t help but see the parallels to Microsoft’s current AI push.

The moves that Microsoft kicked off that day to build internet connectivity into all its products would reverberate throughout the next decade, helping to lay the foundation for the dot-com boom years and arguably the eventual rise of cloud computing.

The release of Internet Explorer 2.0 as a free, bundled browser, the internet-enablement of Microsoft Office, the complete revamping of the still-new MSN online service, Microsoft’s licensing of Java from Sun Microsystems and a focus on how the internet might be used commercially were all pieces of the Microsoft plan unveiled that day.

Internet Explorer 2 was a modest, but ambitious, part of Microsoft’s 1995 internet enablement strategy. (GeekWire Screenshot / Geof Wheelwright)

“The internet is the primary driver of all new work we are doing throughout the product line,” Bill Gates told the assembled technology press in 1995. “We are hard core about the internet.”

Substitute the word “AI” for “internet” and you have a statement that current Microsoft CEO Satya Nadella could have made at any moment in the last couple of years.

“Fifty years after our founding, Microsoft is once again at the heart of a generational moment in technology as we find ourselves in the midst of the AI platform shift,” Nadella wrote in his 2025 annual letter to shareholders. “More than any transformation before it, this generation of AI is radically changing every layer of the tech stack, and we are changing with it.”

Whether you are using the Microsoft Azure cloud platform; running a Windows 11 PC, tablet, or laptop; spending time on LinkedIn; or using Microsoft 365, you will find AI baked in.

Comparing then and now, there are insights in both the similarities and the differences, and lessons from Microsoft’s mid-’90s missteps and successes that are still relevant today.

What’s the same?

The challenge of navigating the shift to a new generation of technology in a large, fast-moving company is the biggest similarity between now and 30 years ago.

Bill Gates launches Windows 95 in August 1995, just four months before the company’s massive internet pivot. (Microsoft Photo)

Microsoft was a lot smaller in 1995, but it was still the dominant force in the software industry of its day. When the company launched Windows 95 in August of 1995, it came with the first versions of both Internet Explorer and MSN. Within four months, it had to ship new, better versions of those products alongside a whole lot of other changes.

The push for speedy change grew out of something the company had been telling its senior leaders for several months prior to the launch of Windows 95: It had to move fast and do more if it was going to catch up in a race that it couldn’t afford to lose.

Gates’ famous “internet tidal wave” memo from May 26, 1995 (which later became an antitrust exhibit) spelled out both the threat and opportunity — calling the internet “the most important single development to come along since the IBM PC was introduced in 1981.”

Later in the memo, Gates acknowledged a significant problem: Microsoft would have to explain why publishers and internet users should use MSN instead of just setting up their own website — and he admitted that the company didn’t have a great answer.

Fast forward to March 2023, a few months after Microsoft partner OpenAI launched ChatGPT, when Satya Nadella made the scale of the AI era clear in a speech on the future of work.

“Today is the start of the next step in this journey, with powerful foundation models and capable copilots accessible via the most universal interface: natural language,” Nadella said. “This will radically transform how computers help us think, plan, and act.”

Of course, Microsoft CEOs have learned a lot over the last 30 years, including the importance of not pointing out the company’s shortcomings in memos that could end up being seen by the rest of the world. Nadella offered nothing like Gates’ MSN admission. But his comments about the size of the AI challenge and opportunity were a direct parallel to the urgency that Gates expressed about the internet 30 years ago.

What’s different?

In the world of PC operating systems and software, Microsoft in the 1990s was king — with few competitors that came even close to the kind of market share it enjoyed. It was arguably late in making a bet-the-company pivot to the internet, but doing so from a very strong position.

Thirty years later, amid the rise of artificial intelligence, Amazon, Google, Nvidia, OpenAI, and Anthropic are part of a more complex network of competitors and partners.

Back in 1995, the big competition was perceived as coming from Netscape and other fast-moving internet startups — and Microsoft was the behemoth battling the insurgents.

The New York Times’ headline about the 1995 event summed up the framing: “Microsoft Seeks Internet Market; Netscape Slides.” As The Seattle Times put it, “Microsoft plays hardball — Game plan for the Internet: Crush the competition.” Many others echoed the theme.

The Seattle Times’ coverage of Microsoft’s internet pivot captured the competitive themes of the day. (Click to enlarge)

I saw that competitive dynamic first-hand at the press event, when by a stroke of luck I ended up sitting beside Bill Gates at lunch. I recall him being a little annoyed by questions about the Java licensing deal with Sun and the broader press interest in the Netscape/Microsoft narrative. He wanted to focus on the broader impact of the day’s announcements.

He stressed, for example, that the licensing by Microsoft of Sun’s Java programming language for use with Microsoft’s Internet Explorer browser was not really a big deal.

“Java you can recreate trivially,” Gates told me, brushing off the licensing deal as a routine business decision, not much different than many others Microsoft made over the years.

The scale is also drastically different. For example, my January 1996 cover story for Microsoft Magazine quoted Gates explaining how the “150 million users of Windows” would benefit from the internet integration it was undertaking across 20 new products and technologies.

In today’s terms, those numbers look tiny. In a blog post earlier this year, Microsoft executive vice president Yusuf Mehdi said Windows now powers more than 1.4 billion monthly active devices. That doesn’t include Microsoft’s massive cloud computing business, Microsoft 365, LinkedIn, Xbox, and its already-significant AI-attributable revenue from Copilot.

The investment gap is more dramatic, even adjusted for inflation. Microsoft poured more than $88 billion into capital expenditures last fiscal year, much of it on AI infrastructure. In 1995, the company’s $220 million deal with NBC to launch MSNBC sounded like a lot of money.

That MSNBC deal, however, highlights another important contrast between the present and the past. In 1995, no one really knew where the internet (and the web) was going to go. Fortunes were made and lost trying to predict which business models would work online.

Tim Bajarin, CEO of the consultancy Creative Strategies and a longtime industry analyst, says Microsoft is better positioned now than it was in 1995. The difference: we already have the underlying architecture for useful AI applications. That wasn’t true with the internet back then.

“We didn’t see the value proposition until we saw the role of applications built on a web-based architecture,” Bajarin said. “That is what is significantly different.”

Lessons for today

Microsoft’s AI push, Bajarin said, will succeed only if it delivers genuine value — implementations that solve real problems and show clear return on investment.

Recent headlines suggest not everyone is convinced. ‘No one asked for this’: Microsoft’s Copilot AI push sparks social media backlash, declared Germany’s PC-WELT magazine. It’s the same question Gates couldn’t answer about MSN in 1995: Why should anyone use this?

Microsoft CEO Satya Nadella speaks at the company’s 50th anniversary event. (GeekWire File Photo / Kevin Lisota)

Perhaps the biggest lesson on the competition front is that there is no guarantee of longevity or relevance in tech. Only one of the competitors listed in the December 1995 New York Times story is still around – IBM – and it is a vastly different company than it was then.

There is one more lesson, about the cost of success. Microsoft’s aggressive internet push worked — but it also triggered a Department of Justice investigation that lasted from 1998 to 2001. Competing hard is essential. Competing too hard has consequences.

But that’s a story for another decade.

Read the whole story
alvinashcraft
just a second ago
reply
Pennsylvania, USA
Share this story
Delete

Homebrew Can Now Help You Install Flatpaks Too

1 Share
"Homebrew, the package manager for macOS and Linux, just got a handy new feature in the latest v5.0.4 update," reports How-To Geek. Brewfile install scripts "are now more like a one-stop shop for installing software, as Flatpaks are now supported alongside Brew packages, Mac App Store Apps, and other packages." For those times when you need to install many software packages at once, like when setting up a new PC or virtual machine, you can create a Brewfile with a list of packages and run it with the 'brew bundle' command. However, the Brewfile isn't limited to just Homebrew packages. You can also use it to install Mac App Store apps, graphical apps through Casks, Visual Studio Code extensions, and Go language packages. Starting with this week's Homebrew v5.0.4 release, Flatpaks are now supported in Brewfiles as well... This turns Homebrew into a fantastic setup tool for macOS, Linux, and Windows Subsystem for Linux (WSL) environments. You can have one script with all your preferred software, and use 'if' statements with platform variables and existing file checks for added portability.

Read more of this story at Slashdot.

Read the whole story
alvinashcraft
24 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

Microsoft is bringing some massive visual changes to PowerToys v0.97

1 Share
We know that PowerToys fans are always looking out for new modules to play with, and Microsoft is quite generous in sprinkling these across releases. But new releases are also about new features, bug fixes, and important tweaks and changes. In an upcoming release, Microsoft is planning some significant changes for the suite of utilities. Key among the changes is support for theming and using custom backgrounds. One of the modules in line for these changes is the beloved Command Palette. Changes are due to be introduced in PowerToys v0.97, although we do not yet have a specific release date… [Continue Reading]
Read the whole story
alvinashcraft
48 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

Rust 1.78.0: What's In It?

1 Share

The Rust team is happy to announce a new version of Rust, 1.78.0. Rust is a programming language empowering everyone to build reliable and efficient software.

\ If you have a previous version of Rust installed via rustup, you can get 1.78.0 with:

$ rustup update stable

\ If you don't have it already, you can get rustup from the appropriate page on our website, and check out the detailed release notes for 1.78.0.

\ If you'd like to help us out by testing future releases, you might consider updating locally to use the beta channel (rustup default beta) or the nightly channel (rustup default nightly). Please report any bugs you might come across!

What's in 1.78.0 stable

Diagnostic attributes

Rust now supports a #[diagnostic] attribute namespace to influence compiler error messages. These are treated as hints which the compiler is not required to use, and it is also not an error to provide a diagnostic that the compiler doesn't recognize. This flexibility allows source code to provide diagnostics even when they're not supported by all compilers, whether those are different versions or entirely different implementations.

\ With this namespace comes the first supported attribute, #[diagnostic::on_unimplemented], which can be placed on a trait to customize the message when that trait is required but hasn't been implemented on a type. Consider the example given in the stabilization pull request:

#[diagnostic::on_unimplemented(
    message = "My Message for `ImportantTrait<{A}>` is not implemented for `{Self}`",
    label = "My Label",
    note = "Note 1",
    note = "Note 2"
)]
trait ImportantTrait<A> {}

fn use_my_trait(_: impl ImportantTrait<i32>) {}

fn main() {
    use_my_trait(String::new());
}

\ Previously, the compiler would give a builtin error like this:

error[E0277]: the trait bound `String: ImportantTrait<i32>` is not satisfied
  --> src/main.rs:12:18
   |
12 |     use_my_trait(String::new());
   |     ------------ ^^^^^^^^^^^^^ the trait `ImportantTrait<i32>` is not implemented for `String`
   |     |
   |     required by a bound introduced by this call
   |

\ With #[diagnostic::on_unimplemented], its custom message fills the primary error line, and its custom label is placed on the source output. The original label is still written as help output, and any custom notes are written as well. (These exact details are subject to change.)

error[E0277]: My Message for `ImportantTrait<i32>` is not implemented for `String`
  --> src/main.rs:12:18
   |
12 |     use_my_trait(String::new());
   |     ------------ ^^^^^^^^^^^^^ My Label
   |     |
   |     required by a bound introduced by this call
   |
   = help: the trait `ImportantTrait<i32>` is not implemented for `String`
   = note: Note 1
   = note: Note 2

\ For trait authors, this kind of diagnostic is more useful if you can provide a better hint than just talking about the missing implementation itself. For example, this is an abridged sample from the standard library:

#[diagnostic::on_unimplemented(
    message = "the size for values of type `{Self}` cannot be known at compilation time",
    label = "doesn't have a size known at compile-time"
)]
pub trait Sized {}

\ For more information, see the reference section on the diagnostic tool attribute namespace.

Asserting unsafe preconditions

The Rust standard library has a number of assertions for the preconditions of unsafe functions, but historically they have only been enabled in #[cfg(debug_assertions)] builds of the standard library to avoid affecting release performance. However, since the standard library is usually compiled and distributed in release mode, most Rust developers weren't ever executing these checks at all.

\ Now, the condition for these assertions is delayed until code generation, so they will be checked depending on the user's own setting for debug assertions -- enabled by default in debug and test builds. This change helps users catch undefined behavior in their code, though the details of how much is checked are generally not stable.

\ For example, slice::from_raw_parts requires an aligned non-null pointer. The following use of a purposely-misaligned pointer has undefined behavior, and while if you were unlucky it may have appeared to "work" in the past, the debug assertion can now catch it:

fn main() {
    let slice: &[u8] = &[1, 2, 3, 4, 5];
    let ptr = slice.as_ptr();

    // Create an offset from `ptr` that will always be one off from `u16`'s correct alignment
    let i = usize::from(ptr as usize & 1 == 0);

    let slice16: &[u16] = unsafe { std::slice::from_raw_parts(ptr.add(i).cast::<u16>(), 2) };
    dbg!(slice16);
}


thread 'main' panicked at library/core/src/panicking.rs:220:5:
unsafe precondition(s) violated: slice::from_raw_parts requires the pointer to be aligned and non-null, and the total size of the slice not to exceed `isize::MAX`
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
thread caused non-unwinding panic. aborting.

Deterministic realignment

The standard library has a few functions that change the alignment of pointers and slices, but they previously had caveats that made them difficult to rely on in practice, if you followed their documentation precisely. Those caveats primarily existed as a hedge against const evaluation, but they're only stable for non-const use anyway. They are now promised to have consistent runtime behavior according to their actual inputs.

  • pointer::align_offset computes the offset needed to change a pointer to the given alignment. It returns usize::MAX if that is not possible, but it was previously permitted to always return usize::MAX, and now that behavior is removed.
  • slice::align_to and slice::align_to_mut both transmute slices to an aligned middle slice and the remaining unaligned head and tail slices. These methods now promise to return the largest possible middle part, rather than allowing the implementation to return something less optimal like returning everything as the head slice.

Stabilized APIs

  • impl Read for &Stdin
  • Accept non 'static lifetimes for several std::error::Error related implementations
  • Make impl<Fd: AsFd> impl take ?Sized
  • impl From<TryReserveError> for io::Error

\ These APIs are now stable in const contexts:

  • Barrier::new()

Compatibility notes

  • As previously announced, Rust 1.78 has increased its minimum requirement to Windows 10 for the following targets:
  • x86_64-pc-windows-msvc
  • i686-pc-windows-msvc
  • x86_64-pc-windows-gnu
  • i686-pc-windows-gnu
  • x86_64-pc-windows-gnullvm
  • i686-pc-windows-gnullvm
  • Rust 1.78 has upgraded its bundled LLVM to version 18, completing the announced u128/i128 ABI change for x86-32 and x86-64 targets. Distributors that use their own LLVM older than 18 may still face the calling convention bugs mentioned in that post.

Other changes

Check out everything that changed in Rust, Cargo, and Clippy.

Contributors to 1.78.0

Many people came together to create Rust 1.78.0. We couldn't have done it without all of you. Thanks!


The Rust Release Team

\ Also published here

\ Photo by Ubaid E. Alyafizi on Unsplash

Read the whole story
alvinashcraft
1 minute ago
reply
Pennsylvania, USA
Share this story
Delete

Where is the non-smoking section of a cigar bar, please?

1 Share
From: Iot Coffee Talk
Duration: 8:20
Views: 6

Leonard and Rob are in Las Vegas for re:Invent 2025 at a cigar bar at the Wynn looking for the non-smoking section.

Read the whole story
alvinashcraft
1 minute ago
reply
Pennsylvania, USA
Share this story
Delete

Deploying Windows Servers in an Azure Availability Set

1 Share
From: ITOpsTalk
Duration: 9:18
Views: 4

In this video you will learn how to deploy Windows Servers in an Azure Availability Set. By using Azure Availability Sets with Premium Storage, you can achieve 99.999 SLA for a workload.

➡️ https://learn.microsoft.com/en-us/azure/virtual-machines/availability-set-overview

➡️ My social links: https://aka.ms/orin

Orin voice cloning done with: https://elevenlabs.io
Orin avatar trained with: https://d-id.com

Read the whole story
alvinashcraft
1 minute ago
reply
Pennsylvania, USA
Share this story
Delete
Next Page of Stories