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

e258 – Pretty Slides, Painful Production: What’s Behind the Deck?

1 Share

Show Notes – Episode #258

Two high-profile presentations can look equally polished on the big screen yet have dramatically different production realities behind them. In Episode 258, Troy Chollar and Lori Chollar compare two recent, but separate, presentation projects and look beyond slide-level design to the behind-the-slides PowerPoint infrastructure that can aid in keeping presentation content consistent, easily editable, and production-ready.
The conversation moves through theme colors, fonts, master layouts, alignment, speaker notes, sections, file optimization, and the realities of making changes while executives are rehearsing, with many insights into the presentation workflows TLC Creative Services has on their showsite event projects. The audience may never see a great template, but everyone responsible for creating, operating, and maintaining the presentation benefits from it.


Conversation Highlights

  • Why two equally attractive executive presentations created very different production experiences.
  • How theme colors, theme fonts, placeholders, and layouts create consistency and speed up revisions.
  • Why duplicating finished slides can have unexpected results.
  • How PowerPoint sections help operators navigate large show decks and organize presenter PDFs.
  • Why alignment and font size take on a different importance in large screen events.
  • Font-management practices that make presentation handoff safer, including audits and reference PDFs.
  • Why file optimization and production engineering matter even though they are not strictly template features.
  • How a well-built template can shift production time from repairing slides to expedited presentation edits and being show-ready.

Resources from this Episode:  

Show Suggestions? Questions for your Hosts?

Email us at: info@thepresentationpodcast.com

New Episodes 1st and 3rd Tuesday Every Month

Thanks for joining us!

The post e258 – Pretty Slides, Painful Production: What’s Behind the Deck? appeared first on The Presentation Podcast.

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

Microsoft Sovereign Cloud demo: Choice and control for every workload

1 Share
From: MicrosoftAzure
Duration: 4:15
Views: 66

Discover how Microsoft Sovereign Cloud helps you apply the right level of control to every workload. The Sovereign Control Panel gives you oversight of your sovereignty posture in one Azure portal view, showing how your data residency, confidentiality, and business continuity controls are applied so you can drill in and act where it matters.

When continuity is the priority, the panel shows which workloads are ready to move from Azure to Azure Local, a private cloud you own and operate. Critical workloads can then shift to fully disconnected operations, running on a local control plane without interruption. Foundry Local and GitHub Enterprise Local bring AI models and developer tools right alongside your most sensitive data.

From oversight to operational independence, see how Microsoft Sovereign Cloud gives you the choice and control to meet your unique requirements.

Learn more at Microsoft Sovereign Cloud: https://msft.it/6057xDvRJ

Read the blog: https://msft.it/6058xDvRK

#SovereignControlPanel #AzureLocal #DigitalSovereignty

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

Small IT Teams Big Impact: Azure SRE Agent

1 Share
From: MicrosoftAzure
Duration: 4:22
Views: 624

How can small IT teams keep up with day-to-day responsibilities, and still find time to be proactive? Azure SRE Agent (Site Reliability Engineer Agent) streamlines IT work processes, helps you investigate and prevent issues, and automates routine tasks like reporting. Find out how Azure helps small and medium-sized businesses become more impactful through AI-enhanced tools like Azure SRE Agent.

Try Azure SRE Agent: https://msft.it/6050xDX5o

#SiteReliabilityEngineer #SRE #AzureSREAgent

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

Node.js 27.0.0-alpha.0.1.1 (Alpha)

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

The pioneering coding tricks that built Doom and Quake

1 Share
Ryan chats with John Romero, creator of the WAD file and the video game Doom, about the self-modifying code and blitting techniques that made Wolfenstein run so fast on early PCs, the mod-friendly architecture that turned Doom into a cultural phenomenon, and why the raw creative problem-solving of Quake proves that human ideas will always beat AI coding agents.
Read the whole story
alvinashcraft
57 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

Event Sourcing: the Timeline projector

1 Share

This is the last post in my series on Event Sourcing. In this post, we’ll take a deep dive into the Timeline projector that we use to project bi-temporal events into a timeline.

Quick reminder from earlier posts

There are two ways to create a timeline from events.

The version using create, update, and delete events, creates a timeline like show in this image:

The version using set and remove events creates a slightly different timelines:

I’ll guide you now through the whole TimelineProjector.fs file. All the below code samples are consecutive pieces from that file.

Types used for configuration of the projector

As seen in earlier examples, the CreateProjectionAction type is used to define how each event has to be interpreted for create-update-delete-timelines:

  • Creates: marks a creation event – the projection is “alive” from Effective onwards. E.g. an employee is created to exist from 13.11.2026 onwards. Since creation events hold all data needed to create the projection, the projection is passed as the second tuple value.
  • Updates: marks an event that updates an existing projection. The second tuple value is the function used to update the old projection to the new one. Again, Effective is the timestamp from which the updated value is available.
  • Deletes: deletes the projection at the given Effective.
  • ModifyPerpetually: the projection is updated over the whole timeline.
  • Skip: the event is skipped in this projection. This is useful when several different projections exist on the same event stream.

The SetProjectionAction is the equivalent for set-remove-based timelines:

  • Sets: sets a projection from Effective onwards.
  • Changes: updates a projection with the given Effective timestamp.
  • Removes: removes the projection from the timeline at Effective.
  • Skip: skips the event in this projection.

To complete the definition, we need some more configuration:

The OverrideBehavior defines how set-remove-based timelines deal with set events that have a later application, but an earlier effective than already existing set events. (see Event Sourcing: set-and-remove-based bi-temporal events)

ProjectionActionConfiguration defines which variant of the timeline we want to use.

Finally, the ProjectionConfiguration holds the above value plus a function that allows the projector to get the application timestamp of an event.

The Timeline Projector Module

The Timeline Projector module contains the functions to project a list of events given a projection configuration.:

Set-remove-based Timeline

shouldApplyEvent defines whether an event is ignored when the value it would set is overriden by an event with a smaller or equal effective timestamp, but a later application timestamp.

The folder function is the main part of the projection. We fold/loop over the events and build up the phases of the timeline. If the event should be applied, we determine how we need to interpret the event given the configuration (sets, changes, removes, or skipped). Then we build a new phase with the (updated) value. We add the phase to the current list of phases that is returned (= the phases in the next iteration of the loop). We build the phases in reverse order because adding at the front is faster.

Before we can call the folder function, we need to order the events correctly by their effective timestamp, application timestamp, and their kind. Ordering by kind is important so that, for example, when we have a Sets event and a Changes event with the same effective and application timestamps, the Sets event comes first.

Finally, we check whether the fold resulted in any phases. If not, we have a NonExistent timeline. Otherwise we reverse the phases and return a Timeline that is Existent.

Create-update-delete-based Timeline

In this variant, we first need to partition the events into two buckets: events with an effective timestamp, and events without. Mapping to an array proved to be faster in benchmarks.

Events without an effective timestamp are then sorted by their application timestamp.

Events with an effective timestamp are sorted primarily by their effective timestamp, then by their application timestamp, and by their kind as a decider. This makes sure that events with the same effective and application are sorted in a meaningful way (create before update before delete).

The applyEventsWithoutEffective is used during the projection to apply the ModifyPerpetually events, which change the values in every phase given their application timestamp is later than the event (with effective timestamp) currently projected.

The folder function loops over the event with an effective timestamp and creates phases based on the interpretation of the event given by the configuration. When a phase is created, the applyEventsWithoutEffective function is called to get the final value for that phase. The “state” value of the folder function keeps track of the created phases, and the current projection.

The current projection is finally used to determine which kind of timeline we return. Again, we need to reverse the phases because we built them in reverse order (faster).

Projection Functions

To complete the module, we provide several variants of how events are projected into timelines: as a Map, a IReadOnlyDictionary, or as a list. Maps are better to perform further transformations, dictionaries are faster, and a list is sometimes easier to handle.

The grouper function is used to determine the individual event streams in the list of the events. Every event stream results in a timeline.

Benchmark

The projection should be fast, so we used a Benchmark.Net benchmark to optimise the code. We run some typical scenarios in our system.

Pretty fast. 😊

Summary

A couple of lines of code are at the heart of our system and run a couple of thousand times per second. We chose a custom-built way to project events for two reasons. When we started with event sourcing, there were no .NET libraries available. And over the years, we realised that we have some special requirements – I explained them over the course of this blog post series – that can be dealt with more easily with a custom solution than with the libraries available nowadays.

If you ask me whether you should build your own projectors (and infrastructure code to store events) or choose an existing library, I can’t aswer this question for you. However, I can give you a list of question that you should answer before making a choice:

  • How flexible are you in choosing a database (some libaries are bound to a certain database)?
  • Are bi-temporal events common in your domain?
  • Are you working on a long running product or in rather short lived projects?

With that, I consider this blog post series finished. Thanks for reading along.

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