WHC Lessons

Coding Smashing Syntax WHC Lessons

From WHCLessons to Smashing Syntax: Rebranding the Code

Charles McCrimmon
Smash-Syntax Draft Logo
Draft Logo

For several years, my educational video work existed under the name WHCLessons. It was a practical label at the time—most of the material was recorded as a supplement to my teaching at West Highland College, and the channel primarily served as a repository for short, focused teaching clips.

However, both the institutional landscape and my own teaching practice have evolved. The college no longer exists in that form, and my work has expanded far beyond that original context. The name increasingly felt like a historical artefact rather than an accurate reflection of the content.

It is therefore time to retire WHCLessons and move forward under a new identity: Smashing Syntax.

Why the Change?

The original name anchored the content to a specific institution and moment in time. For students and developers discovering the material now, it offered little clarity about what the channel actually provides.

The intent behind the videos has always been broader. My work spans multiple educational levels and pathways, from supporting school-level learners navigating SQA qualifications to engaging with degree-level software engineering theory and practice. The constant aim has been to reduce the perceived distance between “entry-level” and “advanced” computing by presenting concepts as part of a continuous learning journey rather than isolated stages.

The rebrand reflects that continuity.

The Identity Behind Smashing Syntax

The name is deliberate and rooted in both discipline and place.

“Smashing.” In Scottish usage, calling something smashing means it is excellent, solid, dependable — something done properly. It carries an everyday confidence rather than hype. That is exactly the ethos I want the channel to embody: not flashy computing content, but clear, well-explained, academically grounded material that helps learners succeed.

It also reflects a mindset. The aim is for students to smash their coursework, assessments, interviews, and technical challenges — not through shortcuts, but through understanding.

“Syntax.” The foundation of everything we build in computing. From a first Python statement to complex distributed architectures, syntax is where thinking becomes executable. It is the common thread across every stage of the learning journey.

Together, the name anchors the channel in two things: a Scottish educational voice, and a focus on the fundamentals that actually carry learners forward.

Positioning Within the Wider Ecosystem

This blog remains the central hub for my academic, technical, and personal work. It will continue to host longer reflections, teaching materials, and research-informed perspectives.

Within that broader landscape:

  • Smashing Syntax becomes the dedicated home for computer science and software development video content.
  • Galleon Acre remains focused on self-sufficiency, land development, and lifestyle documentation.
  • The blog acts as the connective layer—linking ideas, projects, and outputs across both.

The rebrand is therefore not a simple renaming exercise; it is a structural clarification of purpose.

Unlocking the Archive: Unlisted and Private Content

One of the more significant consequences of this transition is the realisation that a substantial volume of material has accumulated in private or unlisted form.

These include:

  • Short explainer videos created for specific classes or cohorts
  • Walkthroughs of exam techniques and practical assessments
  • Demonstrations of programming constructs across multiple languages
  • Lecture fragments and topic deep-dives never formally published
  • Early prototypes of teaching formats that informed later delivery

Much of this content was produced for immediate pedagogical need rather than public distribution. However, in aggregate, it represents a valuable knowledge base.

Over the coming months, this material will be reviewed, curated, and either:

  • published in structured playlists,
  • re-recorded where clarity or currency requires it, or
  • integrated into new, more coherent series.

The intention is not simply to “release everything,” but to transform a fragmented archive into a usable learning pathway.

Content Direction Going Forward

The channel’s future output will follow three broad strands.

1. Exam and Qualification Support
Targeted guidance for learners navigating National 5, Higher, and Advanced Higher computing, including practical components, common pitfalls, and revision strategies.

2. Core Software Development Practice
Conceptual and applied material covering programming paradigms, data structures, databases, and systems design—aligned with undergraduate learning trajectories.

3. Theory, Architecture, and Professional Context
Longer-form explorations of design patterns, software architecture, cybersecurity principles, and the realities of industry practice.

Across all strands, the emphasis remains consistent: clarity over novelty, structure over noise, and accessibility without dilution.

A Transitional Moment

Rebranding is often framed as a marketing exercise. In this case, it is better understood as an academic and professional recalibration.

The work itself has not changed in its intent: supporting learners, demystifying computing, and making the path from first exposure to professional competence more navigable. What has changed is the scale, the audience, and the clarity with which that mission can now be articulated.

The transition is already underway across YouTube and associated platforms. Over time, the new identity should make it easier for learners to find the material they need, understand where it fits in their journey, and move between levels without artificial barriers.

The direction is clear. The archive is ready to be surfaced. And the next phase of content creation is already in motion.

Coding Employment WHC Lessons

Busy Work Period

Charles McCrimmon

Marking season. Two words that can send shivers down an academic’s spine. While I genuinely love seeing what students create, the sheer volume and, let’s be honest, sometimes the state of submissions can be a real grind. My personal nemesis? The sprawling project folder with code scattered everywhere, forcing me into a click-fest of opening and closing files. A meme, my students were quick to adopt from my constant reminders, “Use the F***EN TEMPLATE!” though never said out loud in this manner. Students were quick to make the jokes… but alas, for some, that’s as far as the advice goes.

Even though tools like VS Code have a “Find in Files” feature, my brain prefers a single stream of information for that initial pass. Multiple tabs quickly become visual noise for me, and I lose my flow.

This frustration led to a little weekend project: a Python script! It’s nothing fancy, but it’s become my secret weapon. I point it at a student’s project folder, and bam – it sucks all the code into one consolidated file. Suddenly, I can get a bird’s-eye view, spot if comments are MIA, and generally assess the lay of the land without playing tab-roulette. It’s amazing how much smoother this makes the initial triage.

I’m planning to share this little script with you all because if it can save me this much headache, maybe it can help you too. Let’s make marking season a little more manageable, shall we?

import os

def combine_files_by_type(root_dir, file_extensions, output_base_name):
    """
    Combines all files of specified extensions in a directory and its subdirectories into separate output files, one for each extension.

    Args:
        root_dir (str): The path to the root directory to search for files.
        file_extensions (list): A list of file extensions to process (e.g., ['.php', '.js']).
        output_base_name (str): The base name for the output files.
                                (e.g., 'combined' will result in 'combined.php', 'combined.js')
    """
    if not os.path.isdir(root_dir):
        print(f"Error: Directory '{root_dir}' not found.")
        return

    for extension in file_extensions:
        output_filename = f"{output_base_name}{extension}"
        files_found_for_extension = False
        
        try:
            with open(output_filename, 'w', encoding='utf-8') as outfile:
                print(f"\nProcessing '{extension}' files into '{output_filename}'...")
                file_count = 0
                for subdir, _, files in os.walk(root_dir):
                    # Sort files for consistent order, helps if order matters somewhat
                    sorted_files = sorted(files)
                    for filename in sorted_files:
                        if filename.endswith(extension):
                            files_found_for_extension = True
                            filepath = os.path.join(subdir, filename)
                            relative_path = os.path.relpath(filepath, root_dir) # Get path relative to root_dir
                            try:
                                with open(filepath, 'r', encoding='utf-8') as infile:
                                    content = infile.read()
                                    # Use relative path in the separator for better context
                                    outfile.write(f"\n\n----- {relative_path} -----\n\n")
                                    outfile.write(content)
                                    print(f"  Added: {filepath}")
                                    file_count += 1
                            except Exception as e:
                                print(f"  Error reading file {filepath}: {e}")
                
                if files_found_for_extension:
                    print(f"Successfully combined {file_count} '{extension}' file(s) into '{output_filename}'")
                else:
                    print(f"No '{extension}' files found in '{root_dir}'. '{output_filename}' created empty or not at all if it existed.")
                    # If no files were found, we would have an empty combined file. We can delete it if it's truly empty.
                    if os.path.exists(output_filename) and os.path.getsize(output_filename) == 0:
                        os.remove(output_filename)
                        print(f"Removed empty output file: '{output_filename}'")


        except Exception as e:
            print(f"Error writing to output file {output_filename}: {e}")

if __name__ == "__main__":
    input_directory = input("Enter the root directory to search: ")
    output_basename = input("Enter the base name for the combined output files (e.g., 'combined_project'): ")

    # Define the file types you want to process
    extensions_to_process = ['.php', '.js', '.html', '.css', '.sql']

    if input_directory and output_basename:
        combine_files_by_type(input_directory, extensions_to_process, output_basename)
    else:
        print("Input directory and output base name cannot be empty.")
Code language: Python (python)

You missed

Galleon Acre Gardening

New Horizons: Trading the Island for Green Pastures

Coding Smashing Syntax WHC Lessons

From WHCLessons to Smashing Syntax: Rebranding the Code

Coding Personal

Control System PoC

Coding Personal

Game Control System