In decades of giving and attending thousands of presentations, I’ve learned a thing or two about how to give a talk, a webinar and a technology demonstration. Back in 2015, while I was working for Evans Data in Santa Cruz, I created a blog post “Most Everything I learned about presenting I learned from Jerry Weissman“, on the DevRelate site. In that post I covered some of the tips, tricks and techniques that I’ve learned (and co-opted from other great presenters) that helped me improve my presentation skills.
If you are looking for a few quick presentation tips, the following are some of my top suggestions:
Practice your presentation a few times to understand the pacing (if there is a time limit). If you have time, record the presentation and then watch it several times.
Get rid of distractions by turning off notifications, alerts, social/team apps, email, calendar, mute your phone, and set do not disturb on your phone/fitness band.
If you need to keep hydrated, drink still water that is room temperature. Also, use the bathroom before your presentation. Avoid alcohol and too much caffeine.
Watch talks by other great presenters from inside and outside of your field of expertise.
Use more than just a blizzard of bullet points. You can also use quotes, images, short video clips, visualizatons and other ways to avoid a presentation full of text.
There are a number of great books that ca provide additional ways to improve your presentation creation, delivery and distribution. The following are just a few books you might consider owning.
The worst “on-the-fly” (pun intended) Delphi demo I ever wrote was a thread based sort program (Dreaded Sorts). I created the code on the flight from San Jose to Seattle for the Microsoft Windows 95 launch. The launch took place on Thursday August 24, 1995 on the Microsoft campus. Multiple software vendors, including Borland, demonstrated their support for Win95 in tents on the lawn.
During the flight I realized that I didn’t have a Delphi 2 demo that took full advantage of Win95’s 32-bit OS and other features. So, for the duration of flight (approximately 2 hours) I hacked together a 32-bit VCL application using a pre-release version of Delphi. Note: the program still compiles and runs using the latest release of Delphi 11 Alexandria!
Charlie Calvert included my “Dreaded Sorts” program in his Delphi 2 Unleashed book (pages 240-243). The source code for the project can be found on the book’s CD.
To introduce my program Charlie wrote:
“The program shown in Listing 7.9 was written by David Intersimone, a fellow Borland employee. The code has some historical significance, as it was written on the flight to the Windows 95 launch in Seattle. The fact that David was able to do some serious coding on a West Coast shuttle flight shows that almost anything is possible if you set your mind to it!”
The Original Dreaded Sorts Source Code (THSORTS.DPR)
The original name of my on-the-fly demo was THSorts. I eventually called it my “Dreaded Sorts” program when Charlie Calvert asked to include it in his Delphi 2 Unleased book. Take a look at the source code below. You’ll see that it contains many bad programming practices and hacks that I used on the flight to get the demo working. Examples of bad programming practices include using magic numbers, offset coordinate hacks, hard coded array size (Delphi now supports dynamic arrays), changing the caption for the input error message instead of a Message Box popup, etc. The most glaring warning was the note at the top of the main form’s source code: “This example program shows how to set a thread’s priority. Don’t use Canvas property in program like this! Not unless you also use the TThread object and its Synchronize procedure!”
copyright (c) 1996 by David Intersimone
This example program shows how to set a
thread's priority. Don't use Canvas property
in program like this! Not unless you also
use the TThread object and its Synchronize
SysUtils, WinTypes, WinProcs,
Messages, Classes, Graphics,
Controls, Forms, Dialogs,
StdCtrls, ComCtrls, Buttons;
aMax = 300;
TForm1 = class(TForm)
procedure Button1Click(Sender: TObject);
T1 : THandle;
T2 : THandle;
a,b : array[0..aMax-1] of integer;
numItems : integer;
procedure BubbleSort(var ia:array of integer; items: integer);
i,j,t : integer;
DC := GetDC(Form2.Handle);
for i := items downto 0 do
for j := 0 to items-1 do
if ia[j] < ia[j+1] then
t := ia[j];
SetPixel(DC, ia[j+1]+5, j+1+5, clBlue);
SetPixel(DC, ia[j]+5, j+5, clBlue);
ia[j] := ia[j+1];
ia[j+1] := t;
Setpixel(DC, ia[j+1]+5,j+1+5, clYellow);
Setpixel(DC, ia[j]+5,j+5, clYellow);
procedure QuickSort(var ia:array of integer; iLo,iHi : integer);
Lo,Hi,Mid,T : integer;
Lo := iLo;
Hi := iHi;
mid := ia[(Lo+hi) div 2];
DC := GetDC(Form3.Handle);
while ia[Lo] < mid do Inc(Lo);
while ia[Hi] > mid do Dec(Hi);
if Lo <= Hi then
T := ia[Lo];
SetPixel(DC, ia[Lo]+5,Lo+5, clBlue);
SetPixel(DC, ia[Hi]+5,Hi+5, clBlue);
ia[Lo] := ia[Hi];
ia[Hi] := T;
SetPixel(DC, ia[Lo]+5,Lo+5, clLime);
SetPixel(DC, ia[Hi]+5,Hi+5, clLime);
until Lo > Hi;
if Hi > iLo then QuickSort(ia,iLo,Hi);
if Lo < iHi then QuickSort(ia,Lo,iHi);
function BubbleThread(parms:pointer) : LongInt; far;
function QuickThread(parms:pointer) : LongInt; far;
procedure TForm1.Button1Click(Sender: TObject);
i : integer;
ThreadID : dWord;
numItems := strToInt(Edit1.Text);
if numItems <= aMax then
form2 := TForm2.Create(self);
form2.top := 140;
form2.left := 2;
form2.clientheight := numItems+10;
form2.clientwidth := numItems+10;
form2.color := clBlue;
form2.caption := 'Bubble Sort';
form3 := TForm3.Create(self);
form3.top := 140;
form3.left := 320;
form3.clientheight := numItems+10;
form3.clientwidth := numItems+10;
form3.color := clBlue;
form3.caption := 'Quick Sort';
for i := 0 to numItems-1 do
a[i] := random(numItems);
b[i] := a[i];
form2.canvas.pixels[a[i]+5,i+5] := clYellow;
form3.canvas.pixels[b[i]+5,i+5] := clLime;
T1 := createThread(nil,0,@BubbleThread,nil,0,threadID);
T2 := createThread(nil,0,@QuickThread,nil,0,threadID);
Form1.Caption := 'Too Large!';
A Much Better Version of a Delphi Multi-Threaded Sort Demo
A much better version of a Delphi multi-threaded demo shipped in the release version of Delphi 2 (release date: February 10, 1996) is available on GitHub. You can download the Delphi multi threading demo by Bob Ainsbury and Ray Konopka that first appeared at the 1995 Borland Conference.
My Best Delphi Program
The best Delphi program I ever created is one that I haven’t written yet!
The first personal computer I owned was an IMSAI 8080 kit computer that I bought and put together in December 1975.
Putting the IMSAI kit together involved a lot of soldering:
Soldered all twenty-two slot S-100 bus connectors onto the non-solder-masked motherboard
Soldered the front panel circuit board, Intel 8080 processor board and two 4K static RAM boards (lots of chips, connectors, resistors, capacitors, etc.)
Soldered the power supply with its large capacitors
Visually inspected all of the boards, motherboard, checked things with a voltmeter.
Assembled the Front Panel involved snapping on the cool looking blue and red paddle switches and the power switch, inserting the boards into the S-100 connectors.
It was time to plug in the power cord and turn the computer on for the first time (while crossing my fingers, toes, legs and eyes). When I turned it on, the front panel LEDs did light up, but pressing the stop and reset panel switches did nothing. There was no smoke or smell (always a good sign). I looked again at the boards. I pulled out and plugged back in the boards and tried again. No Joy!
I was a member of the Southern California Computer Society (SCCS) which met monthly at the TRW Space Park campus in Redondo Beach California (Note: at the time I was a real time Data General Nova assembly language programmer for a division of TRW – TRW Data Systems in El Segundo California). The monthly meeting was a place to talk about computers, buy kits, trade parts and keep up to date on what was happening in computing outside of work.
At the next monthly SCCS meeting at TRW Space Park (Redondo Beach), I left the computer with one of the vendors at the Saturday meeting, “The Computer Doctor”, who said he would find any soldering or component problems, get it running and give me a call. A week later, I got the call and the computer doctor said he had found some bad soldering, some solder that had spilled across some of the motherboard and computer board traces. I drove to his house and picked up my IMSAI. The doctor also suggested that I buy a bus terminator board from Godbout Electronics to “quiet” the non-solder-masked motherboard.
I brought my IMSAI back to my apartment, plugged it in, pressed the stop and reset paddle switches and my personal computer was ready for me to put some Intel 8080 instructions into memory and press the Run button. The IMSAI manual had a simple starting machine code program to display the LEDs on the front panel. It also had a “game” example where you had to try and turn the LEDs all off our on as they were changing.
The fun fact is that “The Computer Doctor’s” actual name was George Tate. Some of you remember George Tate as the co-founder of Ashton Tate Software and dBase fame.
I still have that original IMSAI 8080 computer and the last time I took it our and turned it on (a couple of years ago), it still worked.