❌

Normal view

There are new articles available, click to refresh the page.
Before yesterdayMain stream

Lesson Logger : From Forgotten Golf Lessons to an App in My Pocket

You can spend good money on golf coaching, but remembering everything you've been taught is another matter entirely.

We've all been there. You have a brilliant lesson, the coach spots something in your swing, a few adjustments later you're striking the ball beautifully, and you leave convinced you've finally cracked golf.

Three days later you're standing on the driving range wondering exactly what it was you were supposed to be doing.

Was it the takeaway? Clubface? Shoulder rotation?

And where did I put those notes?

That, in a nutshell, is why Lesson Logger exists.

The Problem With Golf Lessons

I've always believed that getting proper coaching is one of the best investments you can make in your golf. The difficulty is making sure those lessons translate into improvements on the course.

During a typical session, there's an awful lot of information to take in. Your coach might identify several issues, introduce a new feeling or movement, and give you something specific to practise before the next appointment.

Some golfers record videos, others scribble notes into their phones, while the more organised probably have an actual notebook.

I was collecting information, but I wanted a better way of organising it.

I'd already been developing ForeThought, my macOS golf journal, which had become the central place for everything connected with my game.

But taking a MacBook to a coaching session isn't particularly practical. What I needed was a smaller companion application that could live on my iPhone.

And so Lesson Logger was born.

The Original Idea Was Simple

Lesson Logger initially had one job: record the useful information from a golf lesson before I forgot it. Open the application, create a lesson, select the coach and location, choose the areas of the game covered, and enter the key takeaways.

No unnecessary complications.

I also added an upcoming lessons section, because keeping track of coaching appointments was another little job that deserved its own place. You can plan a future lesson, add the appointment to your calendar and convert it into a completed lesson afterwards.

It sounds like a small feature, but it's one of those things that makes everyday life easier.

The application also grew to include practice history, saved golf locations and a yardage book containing distances for the clubs in your bag. Suddenly I had the information I actually needed at the driving range without having to dig through notes, spreadsheets or screenshots.

Turning Coaching Into Practice

As the application developed, I realised that simply recording what a coach said wasn't enough. The missing link was turning those instructions into actual practice.

Lesson Logger now has Practice Prescriptions and My Practice Plan.

Your coach tells you to work on a particular movement or drill, so you record it against the lesson and add it to your practice plan. When you head to the range, you've got a clear reminder of what you're supposed to be doing.

You can record practice against individual prescriptions, monitor how frequently you've worked on them and mark exercises complete.

If something needs revisiting, you can reopen it. It's not revolutionary technology, but it's a considerably better system than trying to remember what somebody told you three weeks earlier.

Guided Practice and Fitness

Version 2.0 brought a much bigger collection of features.

Guided Practice allows structured ForeThought practice programmes to be imported, with individual sessions and drills that can be followed step by step.

You record what you've completed, where you practised and how it went. There's also Guided Fitness, with programmes covering mobility, activation, warm-ups and other golf-related exercises.

Fitness sessions can be logged separately, whether that's strength training, cardio, yoga, recovery work or even padel.

Recovery information can be read from a compatible JSON file, displaying sleep, heart rate variability and resting heart rate alongside the fitness history. Importantly, Lesson Logger doesn't need direct access to Apple Health to do this.

Bringing Something Useful to Your Coach

Another feature I'm particularly pleased with is the pre-lesson assessment system. Rather than trying to remember how you've been driving the ball, you can record actual patterns during a round.

The Driver and GIR assessments capture things like fairways, missed greens and penalties using quick inputs.

It's deliberately not a complete scoring application. The idea is to collect enough information to identify what might need attention during your next lesson.

Lesson Logger also includes a Coach Overview and PDF reporting, allowing completed programmes and assessment information to be collected into something you can actually share. That seems far more useful than telling your coach that the driver has been 'a bit rubbish lately'.

Your Data, Your Choice

One aspect I'm particularly keen on is the way Lesson Logger stores information.

Rather than hiding everything inside a closed system, the application uses a portable JSON file that can be kept in supported cloud storage, including iCloud Drive or Google Drive.

This also makes it possible for ForeThought on the Mac to import lesson and practice information.

I've been developing an Android version too, because an application designed to help golfers shouldn't necessarily care which phone they're carrying. The iPhone and iPad versions have developed considerably, particularly with the larger layouts and guided programmes introduced in version 2.0.

What Comes Next?

Lesson Logger has evolved from a digital notebook into a genuinely useful coaching and practice companion. There's still more to do, especially around making the connection between ForeThought, Android and the wider training ecosystem as seamless as possible.

But I keep coming back to the problem that started everything.

A golf lesson is only valuable if you remember what you've learned and actually put the work in afterwards. Lesson Logger won't suddenly give you a tour-professional golf swing.

Unfortunately, I haven't worked out how to program that particular feature.

What it will do is make sure the useful information from your coaching doesn't disappear between lesson, and for a golfer constantly trying to improve, that's a pretty good place to start.

Find out more at LessonLogger.

From Tinkering With Macs to Building My Own Apps

If you've been reading The Apple Geek for any length of time, you'll know that I've always enjoyed tinkering with technology. Whether that's breathing new life into an old Mac, experimenting with different operating systems, finding new uses for ageing hardware or getting something working that wasn't necessarily designed to work in the first place, I've always been interested in what technology can do rather than simply how new or expensive it is.

Over the years, that curiosity has led me down some fairly interesting rabbit holes. Some projects have been simple fixes, others have turned into considerably larger undertakings than originally intended. However, somewhere along the way, I've gone from primarily writing about Apple products and experimenting with other people's software to actually developing applications of my own. And not just one application, either. Apparently, I don't know when to stop.

It Usually Starts With a Problem

Looking back, there's a fairly obvious pattern to most of my projects. I'll be doing something perfectly normal, encounter a minor inconvenience and start wondering whether there's a better way of doing it. Sometimes an existing application does exactly what I need, and that's the end of the story. Other times, the available solutions are either unnecessarily complicated, missing something important or simply don't fit the way I want to work.

That's usually when I start thinking about building something myself. It's an innocent enough idea, but one that generally leads to Xcode, Swift, several cups of coffee and an unreasonable number of evenings trying to understand why something that worked perfectly yesterday has suddenly stopped working today. What I've discovered is that the initial idea is often the easy part. Turning it into something reliable, useful and pleasant to use is where the real work begins.

Interestingly, none of the four applications I've been working on started with some grand business plan. They all came from problems I'd encountered personally, usually while doing something completely unrelated to software development. Golf, coaching, padel and classic cars might not sound like particularly connected interests, but they've all provided inspiration for projects that have gradually taken over a surprising amount of my spare time.

ForeThought and the Golf Rabbit Hole

ForeThought was probably the point where things started getting a little out of hand. As a keen golfer, I'm constantly trying to improve my game, and like most golfers, I've experimented with various applications for tracking scores, measuring distances and analysing performance. There are plenty of excellent options available, but I wanted something slightly different. Rather than another application to use while walking around the course, I wanted somewhere to sit down afterwards, review what had happened and work out what I actually needed to practise.

The original idea was a relatively straightforward macOS golf journal. Record a round, enter a few statistics, review the results and perhaps keep some notes about practice sessions. Being someone who spends plenty of time using a Mac, it made sense to build the application around the desktop rather than trying to squeeze everything onto a phone screen. I wanted something that felt like a proper Mac application, with a dashboard, navigation, charts and enough space to present useful information clearly.

Of course, once I had the basics working, I started thinking about everything else that might be useful. Competition results, handicap tracking, lesson history, practice sessions and fitness information all became part of the application. Then came golf bag management, club specifications, distance gapping, wedge matrices and PDF reports. Before long, my simple golf journal had developed into something resembling a complete golf management platform.

The interesting thing was that I wasn't just building features to see whether I could make them work. I was actually using ForeThought to record my own rounds, review my performance and identify areas of my game that needed attention. Seeing an application I'd created become part of my regular routine was a particularly satisfying milestone, and it encouraged me to continue developing the idea.

One Application Becomes Two

ForeThought introduced another problem almost immediately: it's a Mac application, and taking a MacBook onto a driving range or into a golf lesson isn't particularly practical. What I needed was a lightweight companion application that could record useful information while I was away from my desk and make it available to ForeThought afterwards.

That became Lesson Logger, initially designed as a simple digital notebook for recording golf coaching sessions. Anyone who has had a golf lesson will know how easy it is to leave feeling you've finally understood your swing, only to forget half the instructions a few days later. I wanted somewhere to record what my coach had explained, what needed practising and any particular feelings or movements I should remember before the next session.

As with ForeThought, the original scope didn't stay small for very long. Lesson Logger developed to include practice planning, guided programmes, fitness activities, yardages, coaching assessments and reporting. The challenge also moved beyond simply recording information. I wanted the two applications to exchange data, which introduced file handling, JSON structures, cloud storage, automatic imports and all the little complications involved in making separate applications work together.

Android development has added another dimension to the project, particularly when trying to provide a consistent experience across different operating systems. What began as a small iPhone companion has gradually become an important part of a much wider system for recording, understanding and improving golf performance.

From Golf Courses to Padel Courts

You might think that two golf applications would be enough to keep me occupied, but apparently not. During the winter months, when the weather and shorter days make regular golf more difficult, I started playing more padel. It's a brilliant game, excellent exercise and surprisingly addictive, but it wasn't long before I found myself thinking about another little piece of technology that could make the experience better.

That idea became Courta, a padel scoring application designed to make keeping track of points, games and sets as straightforward as possible. The initial concept was simple enough: two teams, clear scoring controls and an interface that could be used without interrupting play. However, padel has several scoring variations, including tiebreaks and Golden Point rules, so even the basic scoring logic needed considerably more thought than I'd originally anticipated.

Then I started exploring connected matches, allowing multiple players to follow the same scoreboard using a shared six-digit code. Suddenly the project involved a server API, synchronisation between devices and support for both iOS and Android. Apple Watch development introduced another challenge entirely: creating controls large enough to use reliably on a tiny screen while playing a competitive sport. I've also spent a surprising amount of time refining spoken announcements so the application knows when to call game point, announce completed games and report the result of a set correctly.

Courta has been particularly interesting because so much of its development depends on real-world testing. Something might look perfectly sensible in Xcode but turn out to be awkward when you're standing on a padel court trying to award a point between rallies. That feedback has been invaluable, and it's a good reminder that designing software isn't just about making something look attractive on a screen.

And Then There Was Parked

My latest project came from a completely different interest: cars. I've always had a soft spot for older German machinery, particularly Volkswagens, and owning or regularly using more than one vehicle creates a small but surprisingly annoying problem. Apple Maps and Google Maps are both capable of remembering where you've parked, but their automatic parking features are generally focused on the most recently parked vehicle rather than keeping track of multiple cars independently.

If you've left a classic car somewhere, switched to your everyday vehicle and parked that somewhere else, the original location isn't necessarily going to be available when you need it. It's not a problem everybody encounters, but it's exactly the sort of inconvenience that makes me wonder whether I could build something better.

Parked is my attempt to solve that problem. The idea is to manage individual vehicles, each with its own saved parking location, while also providing useful everyday features such as parking timers and reminders. It's intended to be equally useful for someone who owns several classic cars and someone who simply wants to remember where they've parked in an unfamiliar town.

I'm continuing to test the iOS application, particularly how it behaves when switching between different vehicles, with Android development and parking-location sharing also part of the plans. Like my other applications, Parked started with a fairly modest idea but has already presented plenty of interesting challenges around location services, reliability and making the whole experience feel effortless.

From Writing About Technology to Creating It

Perhaps the biggest change throughout all this has been how I now look at the software I use every day. I've spent years enjoying Apple's hardware, operating systems and wider ecosystem, but building applications has given me a completely different appreciation for what happens behind the interface. File permissions, synchronisation, database structures, background processing and device compatibility are things most people never need to think about, yet they can make the difference between an application that's genuinely useful and one that's frustrating to use.

I've also learned that software development is largely an exercise in problem-solving and patience. There are days when everything comes together beautifully, followed by others when a tiny change introduces a completely unexpected problem. Something that works perfectly on one device might behave differently on another, and occasionally the solution to an issue turns out to be considerably simpler than the hours spent investigating it.

Despite the frustrations, there's something enormously rewarding about opening an application on your Mac, phone or watch and knowing it's there because you decided to create it. Even better is discovering that it actually solves the problem that inspired it. Whether that's recording a golf lesson, analysing a round, keeping score during a padel match or remembering where you've left a car, these aren't necessarily revolutionary ideas, but they're useful ones.

For me, that's always been the most interesting part of technology. Not simply owning the latest hardware or comparing specifications, but finding ways to make the devices we already have work harder and do something worthwhile.

The Next Chapter for The Apple Geek

The Apple Geek has always been somewhere to document the things I've learned, the experiments I've tried and the technology I've found interesting. From repairing and upgrading ageing Macs to exploring Linux and discovering useful applications, the site has reflected whatever technological rabbit hole I've happened to find myself exploring at the time.

Developing ForeThought, Lesson Logger, Courta and Parked feels like a natural continuation of that journey. Instead of simply reviewing somebody else's software, I'm now in a position to share the experiences of building my own, including the design decisions, technical challenges, successes and inevitable mistakes along the way.

All four applications are at different stages of development, and I've got plenty of ideas about where I'd like to take them next. I'll be writing more about each project individually, looking at where the ideas came from, the features I've built and the lessons learned throughout their development.

If there's one thing I'd like people to take away from all this, it's that you don't necessarily need an enormous business plan or a revolutionary concept to start creating something. Sometimes a small inconvenience, a little curiosity and the willingness to experiment are enough to get started.

I'm not entirely sure what this means for my spare time, particularly when I keep finding new problems I'd like to solve. But I'm enjoying the process, learning an enormous amount and building things I genuinely want to use.

And really, isn't that what being a geek is all about?

LocalSend

AirDrop is the gold standard for sharing files or media between your own devices or Apple users on your local network, Snapdrop filled the void between Apple and Windows / Android devices but its become a little flakey recently which lead me to use Pairdrop.

Pairdrop between non apple to apple of devices it does a lot of stuff right but just like Snapdrop its relying on the browser to do the heavy lifting. But then there is LocalSend.

LocalSend Receive mode, each device gets a local unique identifier

On a quest to bring my now Ubuntu powered MacBook Pro, back in to the ecosystem somewhat I discovered LocalSend its an opensource (which you know I love) application that does the same job as AirDrop on an Apple device.

Its available on

I can be installed via Homebrew, local DMG binaries or via the App Store on Mac. Every base is covered for you.. Linux you have the same choice of binaries options, a snap installer or via FlatHub. The user interface is simple clean and consistent across operating systems, allowing you to support new users and adopters of this program.

Items you want to send are loaded in to App, and when the nearby device comes available you select it and it sends. I find the text function great for sending code or links between devices on different operating systems. The transfers are snappy due to the nature of app to app communication with both acting like server to send and receive, staying away from the bottleneck of modern browsers.

You can build a list of favourites, and give them a more recognisable name for easy identification. There’s also numerous ways of sending the either single send, multiple recipients or via link.

If you like to tweak settings, the settings window has you covered - allowing you to choose a theme, changing the default device name, display language, saving actions on received files, its pretty much covers all you need.

Great app, in constant use at home and work.

5 Years of The Apple Geek

Five years ago, The Apple Geek was born out of a simple idea: to share the knowledge I’d acquired over 20+ years of using Apple products. At that time, I was tinkering with old Macs, exploring Linux alternatives, and discovering ways to extend the life of hardware that most people would have discarded.

The first posts were raw, hands-on tutorials sometimes a little rough around the edges but they reflected a genuine love for technology. Early readers were few, but passionate. The joy of seeing someone successfully breathe new life into their old Mac or fix a stubborn software issue made every late-night post worth it.

Over time, The Apple Geek grew from these humble beginnings. We started to explore deeper topics: macOS tweaks, Linux installations, open-source software, and practical guides for tech enthusiasts of all levels. Thank you for being part of a journey that started with a single idea: β€œSomewhere to document everything I’ve learnt or hacked about with to make work.”

In the past five years, it’s not all been about jotting down what I’ve remembered I’ve ventured down some deep rabbit holes, fully learning more about aspects of the Apple ecosystem I’d previously only scratched the surface of. Each experiment, fix, and project has been a step forward in understanding how Apple technology, Linux, and open-source tools can coexist and complement one another.

Here’s to the next five years of repairs, hacks, open-source discoveries, and geeky adventures. Together, we’ll keep pushing the boundaries of what’s possible one Mac, one Linux install, and one repair guide at a time

Mactracker

Mactracker: The Ultimate Apple Product Database

Apple products have a rich history of innovation, and for enthusiasts, collectors, and IT professionals, keeping track of all the models, specifications, and changes can be overwhelming. Fortunately, Mactracker provides a comprehensive solution. Available for macOS and iOS, Mactracker is a free application that serves as an extensive database of every Apple product ever released. Whether you’re looking for details on the latest MacBook or a vintage Macintosh from the 1980s, Mactracker has you covered.

What is Mactracker?

Mactracker is an application developed by Ian Page that provides an in-depth look at Apple’s entire product history. It includes specifications, release dates, operating system support, benchmark data, and even original pricing. It covers everything from Macs, iPhones, iPads, and Apple Watches to peripherals like keyboards, mice, and software.

For Apple enthusiasts, Mactracker is an essential resource to track the evolution of Apple’s technology. For IT professionals, it’s a valuable tool for managing hardware lifecycles, understanding compatibility, and determining repair eligibility.

Features of Mactracker

Extensive Database

Mactracker includes detailed technical specifications for every Apple product. This includes processor types, RAM, storage, display specifications, and much more. Each product listing also includes a history of operating system support, showing which macOS or iOS versions the device originally shipped with and which updates it can support.

Mac Benchmarks

One of the standout features is the inclusion of benchmark data for Mac computers. This allows users to compare the performance of different models over the years, which is particularly useful when deciding whether to upgrade.

Lifespan & Support Information

Mactracker provides key information on Apple’s support status for devices. It indicates whether a product is still receiving software updates, classified as vintage (no longer sold but still supported), or obsolete (no longer receiving hardware or software support). This is particularly helpful for IT departments managing older Apple hardware.

Software Information

Not only does Mactracker cover hardware, but it also includes details on Apple software releases, including macOS, iOS, and classic Mac OS versions. It provides insights into each operating system’s features, release dates, and compatibility.

Notifications & Tracking

Users can create custom lists of Apple products they own and receive notifications about software updates, warranty coverage, and support changes. This feature is beneficial for Apple users who want to stay informed about their devices.

Why Use Mactracker?

Mactracker is an invaluable tool for anyone with an interest in Apple’s products. Whether you’re an Apple collector researching historical models, a tech enthusiast comparing specs, or an IT professional managing Apple devices, Mactracker simplifies access to detailed product information.

The best part? It’s free and regularly updated to include Apple’s latest releases. With its wealth of information and user-friendly interface, Mactracker remains the ultimate Apple product reference guide.

For more information, visit Mactracker’s official website and download the app for your macOS or iOS device today!

❌
❌