Coder Legion - Recent posts tagged job

I Build Websites That Look Great, Load Fast, and Actually Work

Wed, 14 Oct 2026 20:21:55 +0000

Hi, I’m Sawyer — a web developer and digital creator. I’m currently building websites for people, brands, and projects that need a clean, modern online presence.

If you need a website that is simple to use, responsive on mobile, and built with a polished design, I’d love to help.

What I Build
Personal portfolio websites

Business and service landing pages

Sports and athlete profile sites

Data-driven web applications

React-based front-end projects

Websites with clean UI, animations, and responsive layouts

My Approach
I focus on building websites that are:

Modern and visually polished

Mobile-friendly and responsive

Fast and easy to navigate

Built around your goals, not just generic templates

Ready to deploy and share

I enjoy taking an idea from concept to a real, working website — including planning the structure, designing the interface, building the frontend, and getting it live.

Check Out My Work
You can see my site here:

👉 https://hiresawyer.base31.org

Let’s Build Something
Whether you need a portfolio, a landing page, a sports-data project, or a custom website idea brought to life, feel free to reach out.

I’m open to new projects and collaborations.

Is Your Unity Game Still Choking on a Single Thread?

Thu, 18 Jun 2026 19:45:36 +0000

Is Your Unity Game Choking? Unlock Multithreaded Power with the Job System and Burst Compiler

Introduction

In the rapidly evolving landscape of game development, the performance ceiling of single-threaded execution has become a major bottleneck. If your Unity game grapples with stuttering frame rates, slow AI, laggy physics, or sluggish procedural generation, chances are your heaviest computations are trapped on the main thread. While fundamental optimizations like caching GetComponent are important, they’re merely the first step. To truly unlock modern hardware’s potential and create ambitious, dynamic worlds, you need to graduate to Unity’s Job System and Burst Compiler.

This isn’t about incremental gains; it’s about a paradigm shift. We’re talking about moving expensive calculations from sequential, slow Update() loops to parallel threads, leveraging low-level SIMD (Single Instruction, Multiple Data) optimizations automatically provided by Burst. It’s 2026, and clinging to single-threaded logic for performance-critical tasks is no longer an option – it’s an unforgivable sin against your game’s potential.

Code Layout and Walkthrough: Embracing Parallelism

The core principle of the Job System is to define small, atomic units of work that can be executed independently across multiple threads. This is achieved through the IJob or IJobParallelFor interfaces, combined with NativeArray for safe, high-performance data transfer.

Let’s illustrate with a common scenario: updating the positions of thousands of entities. Instead of iterating in a MonoBehaviour’s Update() loop, we offload this to a job:

1. Define Your Job Struct: First, create a struct that implements IJobParallelFor. This interface is ideal for tasks that involve processing a collection of data in parallel. Crucially, mark your struct with [BurstCompile] to enable the Burst Compiler’s magic.

using Unity.Jobs;
using Unity.Collections;
using Unity.Burst;
using UnityEngine; // For Vector3

[BurstCompile]
public struct MoveEntitiesJob : IJobParallelFor
{
    // Input and output data must be NativeArray types for thread safety
    [ReadOnly] public NativeArray<Vector3> InputPositions;
    public NativeArray<Vector3> OutputPositions;
    public float DeltaTime;
    public float Speed;

    // The Execute method runs for each index in the scheduled range
    public void Execute(int index)
    {
        Vector3 currentPos = InputPositions[index];
        // Example: Move entities forward along Z-axis
        currentPos.z += Speed * DeltaTime; 
        OutputPositions[index] = currentPos;
    }
}

[BurstCompile]: This attribute tells Unity to compile this job using the Burst Compiler. Burst automatically transforms your C# code into highly optimized machine code, often leveraging SIMD instructions to process multiple data points simultaneously.
NativeArray<T>: These are unmanaged arrays that live outside of the C# garbage collector. They are crucial for thread-safe data access and communication between jobs and the main thread. [ReadOnly] ensures the job can’t accidentally modify input data, enhancing safety and optimization.
Execute(int index): This is the core logic. For an IJobParallelFor job, this method is called for each index in the collection you’re processing. The Job System automatically distributes these calls across available threads.

2. Schedule and Complete Your Job: From a MonoBehaviour or a manager script, you’ll prepare your NativeArray data, create an instance of your job, schedule it, and then wait for its completion.

using UnityEngine;
using Unity.Jobs;
using Unity.Collections;

public class EntityMover : MonoBehaviour
{
    public int EntityCount = 10000;
    public float MovementSpeed = 5f;

    private NativeArray<Vector3> _entityPositions; // Stores current positions
    private NativeArray<Vector3> _newPositions;   // Stores results from the job
    private JobHandle _jobHandle;
    private bool _jobScheduled = false;

    void Start()
    {
        // Initialize NativeArrays. Always remember to dispose them!
        _entityPositions = new NativeArray<Vector3>(EntityCount, Allocator.Persistent);
        _newPositions = new NativeArray<Vector3>(EntityCount, Allocator.Persistent);

        // Populate initial positions (example)
        for (int i = 0; i < EntityCount; i++)
        {
            _entityPositions[i] = new Vector3(Random.Range(-50f, 50f), 0, Random.Range(-50f, 50f));
        }
    }

    void Update()
    {
        if (!_jobScheduled)
        {
            // Create and configure the job
            var job = new MoveEntitiesJob
            {
                InputPositions = _entityPositions,
                OutputPositions = _newPositions,
                DeltaTime = Time.deltaTime,
                Speed = MovementSpeed
            };

            // Schedule the job. The second parameter (64) is the innerloopBatchCount.
            // It suggests how many iterations Burst should process in a single batch.
            _jobHandle = job.Schedule(EntityCount, 64);
            _jobScheduled = true;
        }
        else if (_jobHandle.IsCompleted)
        {
            // Wait for the job to complete and retrieve results
            _jobHandle.Complete(); 

            // Copy the results back to the original array for next frame's input
            _newPositions.CopyTo(_entityPositions);

            // Now _entityPositions contains the updated data, which can be
            // used to update actual GameObjects, renderers, etc.

            _jobScheduled = false; // Ready to schedule again next frame
        }
    }

    void OnDestroy()
    {
        // Always dispose NativeArrays when no longer needed to prevent memory leaks!
        if (_entityPositions.IsCreated) _entityPositions.Dispose();
        if (_newPositions.IsCreated) _newPositions.Dispose();
    }
}

Allocator.Persistent: Specifies how the NativeArray memory is managed. Persistent means it lives until manually disposed. Other options like Temp or TempJob are for shorter-lived allocations.
job.Schedule(EntityCount, 64): This enqueues the job to be run. EntityCount is the total number of iterations. 64 is the innerloopBatchCount, which helps the Job System and Burst optimize task distribution.
_jobHandle.Complete(): This is a synchronization point. It forces the main thread to wait until the job finishes. For optimal performance, schedule jobs as early as possible and call Complete() as late as possible, allowing the main thread to perform other tasks concurrently.

Conclusion

Embracing Unity’s Job System and Burst Compiler means moving beyond basic optimizations and tapping into the full potential of modern multi-core processors. You’re not just making your existing game faster; you’re enabling entirely new possibilities: hundreds of dynamic NPCs, massive physics simulations, incredibly reactive worlds, and complex procedural elements, all without sacrificing framerate. Stop being intimidated by the shift from traditional MonoBehaviour patterns. Dive into NativeArrays and IJobParallelFor – your game, and your players, will thank you for liberating its potential. The future of high-performance Unity development is parallel; it’s time to join it.

Software Hiring Poll

Sat, 13 Jun 2026 19:36:29 +0000

Software hiring runs on folklore. There is actual research on what works and what doesn't. Most of the industry has never seen it.
There's a body of peer-reviewed research on how technical interviews work, what they actually measure, and where they fail. Most people I talk to, on both sides of the table, have never read any of it.
I have create a short survey to see what people across the industry have experienced and what they know about the research.
The form has three sections. Experience profile, multiple choice on the literature and a few open-ended scenarios.
About ten minutes.
Anonymous. No email collection.
Open to candidates, interviewers, both, or neither.
https://docs.google.com/forms/d/e/1FAIpQLSd8-jo8ALuA7TuG9iP-8dnPgFfBywP7JXMI3xa2DEq-kV5CRw/viewform
Share the form and help me get better results.

AI Developer | API Integration | Full Stack - Updated my portfolio website

Mon, 11 May 2026 15:07:35 +0000

AI Automation and Agents Developer building intelligent systems and modern web applications. Passionate about machine learning, deep learning, and creating next-gen autonomous agents.

I am a self-taught AI Automation and Agents Developer from Remote. I build intelligent systems, chatbots, and modern web applications with blockchain integration. My expertise includes Machine Learning, Deep Learning, NLP, Smart Contracts, Web3 development, and Full-Stack Web Development with React, Next.js, Node.js, Solidity, and Python. I specialize in creating decentralized applications (dApps), DeFi solutions, and autonomous AI agents. Currently building next-gen AI Agents and JARVIS-like Personal Assistants. Code is poetry, AI is the canvas.

A regular Monday

Mon, 24 Nov 2025 18:45:12 +0000

Monday felt simple and steady. I spent most of the day working on my resume and thinking about the projects I have built over time. Even though it seemed like normal work, it reminded me why these things matter much more than they look.

I started by rewriting my resume. I cleaned up sentences, removed unnecessary words, and tried to make every point clear and direct. While doing this, I realised how important a resume really is. It is often the first thing someone sees before they even meet you. It decides whether they think you are worth a second look. Just a page or two, but it carries the weight of years of work. That thought made me pay more attention to the finer details.

I also reviewed my past projects in a broader way. Instead of focusing on the technical parts, I tried to understand what each one said about me as a person and as a developer. Some showed problem-solving, some showed consistency, and some showed that I can follow through on an idea. It made me see that projects are not just tasks you complete, they are quiet reflections of your growth.

As the day went on, I kept thinking about how important it is to present things properly. Skills matter, but how you talk about them matters too. A project can be strong, but if you do not explain it well, it loses half its impact. A resume can be filled with good work, but if it is cluttered, people miss the real parts. I understood that presentation is not about exaggeration, it is about helping others see your effort clearly.

By the evening, my resume looked cleaner and more honest. I felt more confident about the way I presented myself. The whole day felt like a small reminder that improving the way you show your work is also a part of the work itself.

A regular Monday, nothing fancy, but a meaningful one.