This is the expensive end of the software development lifecycle (SDLC), and it’s exactly where “shift left” aims to intervene. But for teams running microservices on Kubernetes, deploying via GitOps, and shipping frontend assets through edge networks, shifting left isn’t just about running JUnit tests earlier. It’s a fundamental restructuring of how we think about feedback loops in distributed systems.

Beyond the Buzzword

The traditional shift left narrative—moving testing from QA to development—is outdated. In modern cloud-native environments, the “left” extends to the moment an engineer opens an IDE, and the “right” stretches continuously into production. For teams leveraging Infrastructure as Code (IaC), CI/CD pipelines, and polyglot architectures, shifting left means embedding validation, security, and observability into the earliest possible stages of creation.

The economic argument remains compelling: fixing a bug in production costs 100x more than catching it during requirements. But in 2024, the math has new variables. Cloud infrastructure complexity, distributed service dependencies, and the blast radius of configuration drift mean that late-stage failures don’t just cost money—they erode customer trust in ways that automated rollbacks can’t fully repair.

The Stack-Specific Reality

Frontend: From Manual QA to Static Confidence Modern frontend ecosystems (React, Vue, Svelte) offer compile-time safety that previous generations lacked. Shift left here means treating TypeScript errors as pipeline blockers, not suggestions. It means integrating accessibility linting (axe-core, ESLint plugins) into pre-commit hooks rather than relying on end-to-end tests.

Component-driven development using Storybook or Chromatic allows visual regression testing to happen before integration, not after. When your build pipeline generates static assets served via CDN, catching bundle bloat or security misconfigurations (CSP headers, dependency vulnerabilities via npm audit) at the PR stage prevents cache poisoning headaches in production.

Backend: Contracts Over Integration For backend engineers juggling REST or GraphQL APIs across microservices, shift left manifests as contract testing with tools like Pact or Mountebank. Rather than discovering breaking API changes during integration testing, services validate compatibility against consumer contracts during the build phase.

Static application security testing (SAST) and software composition analysis (SCA) now run in milliseconds during local development via IDE plugins or pre-commit hooks. Database schema changes—historically a source of 3 AM pages—are validated using tools like Liquibase or Flyway in CI pipelines, with automated rollback scripts generated before deployment ever reaches staging.

Cloud Infrastructure: Policy as Code This is where shift left thinking has evolved most dramatically. When infrastructure is defined in Terraform, Pulumi, or CloudFormation, “testing” happens before terraform apply. Policy-as-code tools (Open Policy Agent, Checkov, Terrascan) scan IaC for compliance violations, exposed secrets, or cost inefficiencies during the PR review.

GitOps workflows (ArgoCD, Flux) inherently shift left by making the Git repository the single source of truth. But mature teams go further: they use tools like LocalStack or Testcontainers to spin up cloud service mocks during integration tests, validating IAM policies and event-driven architectures (SQS, SNS, Kafka) without touching a live AWS account.

CI/CD: The Immutable Gate Your pipeline is the enforcement mechanism. Modern shift left thinking treats CI/CD not as a conveyor belt, but as a progressive validation system:

• Fast feedback layers: Unit tests and linting complete in under 2 minutes

• Security gates: Container scanning (Trivy, Snyk) happens on image build, not in production registry

• Observability validation: Automated canary analysis and chaos engineering experiments run in staging environments that mirror production topologies

• Feature flags: Decoupling deployment from release allows testing in production with limited blast radius, effectively shifting the “integration” phase rightward while keeping risk contained

The Cultural Inversion

Technology is the easy part. The harder shift is cultural. Traditional models buffered developers from operational concerns. Shift left demands T-shaped engineers who understand that a TypeScript generic and a Kubernetes NetworkPolicy are part of the same quality continuum.

This manifests in pair programming sessions where backend engineers review Terraform plans, or frontend developers writing OpenAPI specifications before touching React code. It requires platform engineering teams to provide “golden paths”—opinionated CI/CD templates and scaffolds that embed security and compliance by default, rather than asking developers to bolt them on.

The “you build it, you run it” ethos extends to developers owning their services’ SLAs from day one. This doesn’t mean 24/7 on-call for everyone, but it does mean engineers use observability tools (Honeycomb, Datadog, Grafana) during development, not just during incidents. Distributed tracing becomes a development tool, not just a debugging one.

The Complexity Trap

Shift left is not about moving all testing to unit tests. It’s about appropriate feedback at appropriate times. Over-rotation creates “shift left fatigue”—developers drowning in pre-commit hooks that take 10 minutes to run, or security scanners with 90% false positive rates.

Smart teams implement a “fail fast” hierarchy:

1. Local: Instant feedback (linting, type checking, unit tests)

2. Pre-merge: Comprehensive but fast (contract tests, container scans)

3. Post-merge: Deep validation (integration tests, performance benchmarks, security penetration testing)

They also recognize that some quality attributes—true user experience, emergent system behaviors, production load patterns—cannot be fully simulated left of deployment. These require sophisticated progressive delivery techniques (canary deployments, blue-green releases) that blur the line between “testing” and “production monitoring.”

The New Feedback Loop

For teams operating at scale, shift left has evolved from a testing strategy to an architecture principle. It’s designing APIs with idempotency in mind because you know retries will happen. It’s writing Terraform modules with built-in cost estimation because finance is now part of the SDLC. It’s treating the developer experience (fast local development, instant preview environments) as a prerequisite for quality, not a nice-to-have.

The goal isn’t zero bugs in production—that’s a fantasy in distributed systems. The goal is reducing the mean time to detection (MTTD) and mean time to resolution (MTTR) by ensuring that when failures occur, they’re surfacing in contexts where engineers have maximal context and minimal pressure.

In modern software, quality isn’t a stage you pass through. It’s the substrate of every commit, every pull request, every infrastructure definition. Shifting left isn’t about doing more work earlier; it’s about recognizing that in a world of continuous deployment, the only sustainable speed is built on confidence—and confidence is manufactured at the source.

To conclude

Shifting left is not a fad or a checkbox—it's a change in how teams design feedback loops so quality becomes a continuous, visible property of every artifact from code and infrastructure to UX and telemetry.

Best centralised docking power station

Why this is the single most transformative pick for most desks

• Real, tested power for a modern laptop desk. WIRED’s 2025 roundup of top laptop docks calls Anker’s 568 one of the strongest options, noting it excels at powering all your other gadgets and supports serious charging and bandwidth.

• WIRED - That praise comes from hands‑on testing and comparison across many docks—exactly what you want when you’re condensing messy cables and chargers into one tidy hub.

• Serious port coverage without a giant block. USB4 up to 40 Gbps, laptop charging to 100W, multiple front‑facing USB‑C ports for fast device charging, plus a host of display and data ports—so you can connect monitors, wired Ethernet, storage, and peripherals from one unit, not a tangle of adapters.

• Cleaner, calmer workspace. Instead of multiple wall chargers, a power strip, and random dongles strewn across the desk, you get a single, slim dock that sits neatly and internally routes everything. It’s a minimalist, durable piece that keeps the desktop footprint small while enabling a full desktop setup.

Tradeoffs

• Premium price - It’s not cheap; that’s the price of serious capability and future‑proofing.

• Windows‑leaning compatibility - Some USB4 docks can have limitations on specific Mac setups; check your system’s exact compatibility before buying, especially if you use macOS as your primary machine.

Best use case
Anyone using a modern laptop as a main workstation—especially with one or more external screens, wired networking, or multiple peripherals—who wants to eliminate cable clutter and speed daily connections.

Cable management organiser

Why this tiny gadget punches above its size

• Immediate, no‑drill tidying for everyday cables - Magnetic clips keep charging or data cables exactly where you want, preventing them from sliding off the desk or tangling. It’s quick to install, easy to re‑stick, and works on many surfaces—perfect for a desk where you plug in phone, earbuds, or a tablet several times a day.

• Strong editorial endorsement - The Strategist’s cable‑organizer guide picked Anker’s magnetic holder as the best magnetic option, noting a $15 price for a two‑pack and clearly recommending it after testing and vetting multiple systems.

• New York Magazine - That kind of testing beyond ad copy gives confidence this is a legitimate, useful product rather than a gimmick.

• Ultra‑low friction, ultra‑low cost - For a few dollars, you quickly transform a messy desk edge into a neat charging station—no heavy hardware or permanent changes needed.

Tradeoffs

• Holding capacity is limited to small cables - It’s great for charging cords and small wires, not thick power cables or large bundles.

• Adhesive eventually needs refreshing - Like most stick‑on organizers, adhesion can fade over time; re‑cleaning or re‑sticking is occasionally necessary.

Best use case
Any desktop where phone or accessory cables regularly fall off the edge, or where a minimal, tidy look matters more than hiding every cable in a box.

Best lighting upgrade to reduce glare and desk clutter

Why slotting this above your screen is so effective

• Works where desk lamps can’t - It clamps on the monitor and shines downward onto the workspace, avoiding screen reflections. That means better lighting for documents, keyboard, or notes without wasting desk space—a perfect solution for tight setups.

• Proven, long‑standing praise - PCWorld’s hands‑on review calls the ScreenBar brilliant for tiny desks or multi‑monitor setups, with the pros of USB power, space savings, and even brightness, though noting the higher cost.

• PCWorld - The same review observed uniform light, effective glare avoidance, and strong practical use, not just a spec sheet.

• Balanced features for real use - USB power, adjustable brightness and color temperature, and a clean, thin design mean it’s not just a novelty lamp; it’s a long‑term, everyday tool that makes working at night or in dim rooms easier.

Tradeoffs

• Premium compared to basic desk lamps - You pay more than a simple lamp, but you gain space and less glare.

• May block some webcams, depending on placement - Any monitor‑mounted bar can interact with a camera; consider your camera position, or use an external webcam mount if needed.

Best use case
Small desks, home offices in shared rooms, or anyone bothered by harsh shadows or screen glare who wants a clean, unobtrusive light.

Best premium space saver and ergonomics

Why it’s worth a premium for a truly clean desk

• Clears the desktop and boosts posture - A monitor arm lifts the screen, freeing surface space for keyboard, notebooks, or a small organiser. Humanscale’s M2.1 is a professional‑grade arm with internal cable routing and a counterbalance system, designed for frequent adjustments and long life, so your desk stays neat without constant cable fuss.

• Strong independent validation - PCWorld highlights Humanscale’s arm line for productivity, ease of adjustment, and built‑in cable management, noting the M2.1 supports better posture and a clutter‑free environment while offering quick, simple installation. staples.com That kind of third‑party recognition matters when choosing a high‑cost accessory you’ll live with daily.

• Reliable build, fewer future headaches - Humanscale’s design emphasises durability, smart stops, and accessories; for a long‑term setup that you won’t want to replace, that’s valuable.

Tradeoffs

• Price - It is expensive, even among professional arms.

• Desk thickness or clamp limits - As with any clamp or grommet arm, verify your desk’s thickness or mounting method is compatible before buying.

Best use case
Small or medium desks where every inch counts, or anyone who wants a premium, long‑lasting arm to keep a tidy workspace and reduce neck or eye strain.

Best tidy stand with storage for small desks

Why this is a great affordable add for cluttered desks

• Raises the monitor and provides quick‑access storage - The stand lifts the screen to a more comfortable height while the drawer neatly holds small items—sticky notes, pens, USB sticks—so they don’t sit on the surface or get lost behind the keyboard. It’s exactly the sort of slice of organization that has a large visual impact for a modest spend.

• Strong buyer feedback on the merchant page - It shows a 5‑star rating with real user reviews, indicating satisfaction and usefulness in everyday setups.

• containerstore.com - That social proof is valuable for budget gear: people actually use it and like it.

• Simple, universal design - Works with most monitors or laptops on desks that need just a bit more surface order, and it’s easy to move between rooms or desks.

Tradeoffs

• Not a substitute for cable management - It frees space and adds storage, but doesn’t hide power strips or cables under the desk. Pair it with clips or a box if you have a lot of cords.

• Limited size - It’s designed for modest setups; very large or heavy monitors may need a stronger stand or an arm instead.

Best use case
Students, small home offices, or anyone who wants an instant tidy look without drilling, wiring, or spending premium‑arm money.

Best low‑cost way to hide power strips and reduce visual clutter

Why a simple box can dramatically change how a desk feels

• Hides the ugly stuff in seconds - Power strips, extra cords, and adapters get tucked out of sight inside the box, so the desk looks cleaner and safer. This is especially helpful for desks near outlets, or setups that rely on larger power bricks.

• Third‑party recommendation from a respected guide - The Spruce’s cable‑management guide selects Chouky as a top box option, pointing to a $26 sale price and highlighting the usefulness of such boxes for organisation.

• The Spruce - This kind of professional pick reinforces that Chouky is a vetted value choice, not just a random listing.

• Much cheaper than pricey trays or racks, and easier to use - No drilling under the desk, no complicated installation—just place it where you want, route cords, close the lid, and you’ve instantly decluttered.

Tradeoffs

• Limited access while in box - If you need to frequently unplug or swap connections, opening the box is needed; this is the normal tradeoff for a cleaner look.

• Ventilation and heat - As with any box covering power gear, ensure adequate ventilation, especially in hot rooms; avoid cramming too many high‑heat devices without airflow.

Best use case
Tight apartments, multi‑use desks, or any workspace where power strips are visible and distracting, and you want an inexpensive, fast fix.

Additional guidance on picking among these

• If you have one clean, modern laptop desk and multiple devices → start with the Anker 568 dock to dramatically reduce cables and centralise power. Add the ScreenBar if lighting is poor, or Cord Keeper if you still have a few stray cords on the desk edge.

• If space is extremely tight or you use a heavy monitor → choose Humanscale M2.1 or another premium arm first to reclaim surface area. Pair with Chouky to hide power strips under or beside the desk.

• If budget is tight but the desk looks messy → start with Cord Keeper and Chouky; add the Container Store stand for quick storage once money allows.

These six picks span budgets and specific pain points, but all are well‑reviewed or recommended by credible sources, making them safe, high‑impact buys for organising a desktop and boosting everyday productivity.

It’s quite simple really and its all within the instructions property. When creating a request with OpenAI client response you can specify the model, instructions and input. When providing instructions you can use things like,

1. Make sure to return the answer in HTML5 semantic format.

2. You like to talk like a pirate, arrr! Your name is Johnarrry Silver and like to let people know at the end of your answer.

3. You are knowledeable and helpful, providing citations for your answers when possible.

Instructions go a long way to create a well crafted and specific prompt response that is actually usable.

Here’s the article it generated.

Brief History o’ Python, matey

How Python first set sail

Python be a high-level programming language created by Guido van Rossum in the late 1980s, with the first public release o’ Python 0.9.0 in 1991. Van Rossum started hackin’ on it at Centrum Wiskunde & Informatica (CWI) in the Netherlands as a successor to a language called ABC, aim’n for cleaner syntax and better error handling.

Name and early design

The name “Python” comes not from the serpent, but from the British comedy show “Monty Python’s Flying Circus”. Van Rossum wanted a language that was:

• Easy to read and write (emphasis on clear, human-friendly syntax),

• Highly extensible with C and other systems,

• Suitable for rapid prototyping and scripting.

Major versions and milestones

• Python 1.0 (1994) – Introduced core features like functions, modules, exceptions, lists, and dictionaries.

• Python 2.0 (2000) – Brought list comprehensions, a full garbage collector, and a more open, community-driven development process.

• Python 3.0 (2008) – A major redesign to fix long-standing quirks; not fully backward compatible with Python 2, but cleaner and more consistent (e.g., print() as a function, better Unicode support).

• End of Python 2 support (2020) – Official support for Python 2 ended, with the ecosystem largely havin’ shifted to Python 3.

Growth and community

Python’s community blossomed through the Python Software Foundation (PSF), created in 2001 to manage intellectual property and support the community. Over time, Python became wildly popular for:

• Web development (e.g., Django, Flask),

• Scientific computing (NumPy, SciPy),

• Data analysis and machine learning (pandas, scikit-learn, TensorFlow, PyTorch),

• Automation, scripting, and education.

By the 2010s and 2020s, Python had become one o’ the most-used languages worldwide, praised for its readability and rich ecosystem of libraries.

References fer further reading

• Python Software Foundation – “History of Python” https://www.python.org/doc/essays/blurb/

• Guido van Rossum – “History of Python” talk (PyCon & essays) https://www.python.org/doc/essays/

• Python timeline (Python Wiki) https://wiki.python.org/moin/History

Arrr, that be a wee slice o’ Python’s voyage through time, signed yer matey, Johnarrry Silver.

I am reading a book called “The Art of Impossible” by Steven Kotler. There’s a chapter called the full intrinsic stack. That sparked my interest to write an article since the overlap in wording with full-stack developer and a feeling of wanting to share what I am learning about Self-determination theory - developers can benefit from this information too.

It talks about the five most powerful intrinsic drivers and how they biochemically and neurologically enable us to achieve impossible feats. That could be great athletic performance, mastery of a skill or skills (public speaking, piano, tai chi), overcoming fears and obstacles in ones life, hiking to the top of Snowdonia on Saturday, the list goes on!

Opposed to that are extrinsic drivers which are motivators outside of oneself, such as, “John has a real cool car and now I want one” or “I’ll give you £100 if you push tommy into the swimming pool“.

You can see the difference. Intrinsic are generally going to be more sustainable and longer-term (but they don’t always have to). They are drivers that come from within, so that not matter what is happening around you, you still have that drive to continue achieving what you set out to do regardless of economic, weather patterns, social norms or train times.

In summa

Extrinsic is being moved by external factors such as rewards, status, opinions of others.

Intrinsic is being internally motivated by curiosity, care, passion, love and values that are inherent in every human.

Our tasks of life can be categorised as either extrinsic or intrinsic in nature. Neither is right or wrong and its important to know the origin of a task as it will give you a good

Know whether your motivation is externally or internally driven helps you approach each of life’s tasks in the right mind-state and constantly tune your willpower to make them a reality.

Read for free the why and how of intrinsic step at https://www.untappedlab.co/untapped-toolkit/intrinsic-stack and get the untapped toolkit to take your potential, performance and wellbeing to the next level.

A junior progression into mid-level is usually an automatic advancement after a minimum 2-years of professional experience within your discipline (i,e; frontend, backend).

A senior however shows leadership and drives on initiatives that align with both company values and personal career development goals.

a Real life example

I am currently going through a career breakthrough phase. I have been sat at the mid-level frontend developer for around 5+ years now. I’ve been at my current employer from well into 1-year and I’m thirsty for my next evolution into seniority. I have been involved in team initiatives and driving these forward, started to mentor other devs and now looking to germinating my own initiative for the next financial year.

I have found an initiative gap in our department that I could drive. The way I’m going to achieve this is by aligning my personal career development goals with the company’s engineering vision.

This has to start at an OKR (Objective, Key, Results) level. This way it can be tracked and monitored throughout the year to ensure that:

1. I stay on track with the initiative

2. Upper management can clearly see what I have achieved

From here it comes down to my own commitment self-learning, knowledge sharing through guild meetings and working groups for others to get involved and having an understanding that I am not the know-it-all for that area but I am someone who is a point-of-contact for the initiative who is willing to go away and find the answers.

What it takes

This type of senior initiative driving can also be called championing. A person who supports and advocates for the development of the initiative because the person is passionate about this area AND it has positive results for the company.

It takes courage to be a driver in this way. You will have to get good at answering unscripted questions from both technical and non-technical perspectives. You must be open and honest in your findings and your current level of understanding. You will need to attend conferences, webinars and meet ups to progress your knowledge. You will need to get good at documentation and probably drawing data flow diagrams or similar. And most of all you will need to discern between what is useless information and what has the most meaningful impact.

Conclusion

In conclusion, progressing from a junior to a senior developer involves more than just accumulating years of experience. It requires demonstrating leadership, taking initiative, and aligning personal career goals with the company's vision. By championing initiatives, engaging in continuous learning, and effectively communicating with both technical and non-technical stakeholders, you as a developer can have an active say in your career development. This journey demands courage, commitment, and the ability to strive towards the betterment of your team.

Below are key questions to help assess whether a package dependency justifies inclusion:

Prior to incorporating any new package, conduct thorough evaluations and secure approval from Technical leads and senior developers, confirming the package's necessity and the absence of superior alternatives.

Follow this assessment checklist:

• What security classification has Snyk assigned? If High or Medium risk, are we comfortable accepting this vulnerability?

• Is there ongoing maintenance? Infrequent updates might indicate unreliability.

• What is the dependency's size impact? If substantial and not reducible through tree shaking, can we accept potential performance implications?

• Is documentation comprehensive? Inadequate documentation will complicate understanding and implementation.

• How robust is the user community and what is the update frequency?

• What dependencies does this package itself require? Do these meet our evaluation criteria?

• What licensing terms apply? Is usage permitted under the current license? Is it commercial or open-source?

Bundlephobia provides a valuable resource for identifying size, download times, what dependencies [package] relies on and whether it is tree-shakeable.

By examining these factors, you can make well-informed choices regarding third-party package integration, thereby reducing risks and supporting long-term project viability.

Serialization and deserialization can be computationally expensive processes. By delaying serialization, you can avoid the performance overhead until it's absolutely necessary. This can lead to more efficient use of system resources and faster execution of your application.

2. Data Consistency

When you delay serialization, you ensure that you are working with the most up-to-date data. Immediate serialization might lock the state of the object at a point where it could still be subject to changes, leading to potential inconsistencies. Delaying it ensures that all necessary updates are included before the data is serialized.

3. Error Handling and Debugging

Keeping data in its native form for as long as possible can simplify error handling and debugging. If errors occur, it's often easier to diagnose and resolve issues with data in its native format rather than in its serialized form. Once data is serialized, it can be more challenging to inspect and manipulate for debugging purposes.

4. Flexibility and Maintainability

By delaying serialization, you keep the data in a flexible state, which makes it easier to make changes or apply transformations. This can be particularly useful in complex systems where data may need to go through multiple stages of processing. Delaying serialization until the final step can simplify the overall architecture and make the system more maintainable.

5. Network Efficiency

In distributed systems, sending serialized data over a network can introduce latency and bandwidth usage. Delaying serialization until the data is ready to be transmitted can reduce unnecessary network load. Additionally, it allows for potential optimizations such as batching multiple pieces of data together before serialization, reducing the number of network calls.

6. Security Considerations

Keeping data in its native form allows you to apply security checks and sanitization before serialization. This can help prevent security vulnerabilities such as injection attacks or data leaks. Once data is serialized, it may be more difficult to apply these checks effectively.

7. Intermediate Processing

In many workflows, data needs to undergo several transformations or be combined with other data before it is finally serialized. By delaying serialization, you ensure that the data remains in a format that is easy to work with during these intermediate steps, facilitating smoother and more efficient processing pipelines.

Practical Example

Imagine a web application that processes user input and stores it in a database. If you serialize the user input immediately after receiving it, any subsequent validations or transformations will require deserialization, modification, and re-serialization, which is inefficient. Instead, by delaying serialization until after all necessary processing steps are completed, you maintain the data in a manipulable state, streamline the workflow, and only serialize once at the end, right before storage or transmission.

In summary, delaying serialization allows for performance optimization, ensures data consistency, aids in debugging, enhances flexibility and maintainability, improves network efficiency, bolsters security, and facilitates intermediate processing.

I would love to read your comments on when and why you use serializers.

Courtesy to https://arvid.xyz/principles/ for the inspiration.

1. DO ONE THING AT A TIME

   Productivity thrives on singular focus. Attempting to juggle multiple tasks only leads to divided attention and diminished results. By concentrating on one task at a time, you can give it your full attention and complete it to a high standard.

2. KNOW THE PROBLEM

   Translate complex bugs or tasks into simpler terms to enhance your comprehension. Breaking down the issue into actionable steps or bullet points provides a roadmap for tackling it effectively.

3. LEARN TO LISTEN

   While asking questions is valuable, listening attentively offers even greater insights. Observing how others approach problems allows you to learn from their creative problem-solving methods.

4. LEARN TO ASK QUESTIONS TO THE RIGHT PEOPLE

   Seeking guidance from the right people can expedite solutions and steer you in the correct direction. Utilise your team's expertise to save time and ensure clarity in your approach.

5. DISTINGUISH SENSE FROM NONSENSE

   In the midst of coding, it's easy to be sidetracked by non-essential details. Focus on the core logic of your task, delegating design-related aspects to teammates, to maintain efficiency and effectiveness.

6. ACCEPT CHANGE AS INEVITABLE

   Accepting change as an inevitable part of development fosters adaptability and resilience. Embrace challenges with an open mindset, ready to pivot when necessary.

7. ADMIT MISTAKES

   Admitting errors promptly facilitates quicker resolution and gets you the necessary support. Transparency and accountability are key components of professional growth. People will respect you more if you own up to it.

8. SAY IT SIMPLE

   Clear and concise communication ensures that your message is understood without distractions. Avoid verbosity and present information clearly.

9. BE CALM

   When faced with setbacks or challenges, maintaining your composure will help you to rationally approach solutions. Release stress through healthy outlets like exercise or deep breathing to regain focus and clarity.

10. SMILE 😃

    A smile is a powerful tool that radiates positivity and fosters a welcoming environment. Embrace optimism in your work and interactions, remembering that every challenge presents an opportunity for growth.

By internalising these principles, you can enhance your productivity, problem-solving abilities, and overall well-being as a frontend developer. Keep striving for improvement and approach your work with confidence and positivity!

Good luck 😃

If you are looking for 1-to-1 frontend development support, schedule a free 30-minute session today -> https://calendly.com/frontendistro/30min

Credit to chester town centre wall art - https://imgur.com/gallery/iVoAJph

Before I begin, I would love to know what you think on this topic, because it is a subjective matter and really only you can decide what works best for you. So please leave a comment with your experience and thoughts on which type of team/company you prefer to work with.

I would like to make clear that I am yet to fully decide which is a better role, being an in-house frontend web developer or being a web developer in an agency, and I am still gathering my experience in both areas.

As frontend development becomes more sophisticated every day with the help of emerging javascript frameworks in 2023 (and beyond), we are more often than not required to set up our development environment and run scripts that compile and build production code-base ready for live publishing.

Frontend Frameworks

Gone are the days when the code we write is the code that gets published. A good example is Sass Preprocessing scripts that can add superpowers to CSS. Browsers have no idea what SCSS is or what Sass is, they only know about CSS. So, SCSS must be converted into CSS via the superpowerful Sass preprocessor. You can read more on that here https://sass-lang.com/guide under the Sass Preprocessing paragraph.

Sass has provided us with super abilities we could only have dreamed of 10 years ago. And JavaScript frameworks scaffold for us the fundamentals for web apps so that we don’t have the rewrite the same base code setup each time, meanwhile keeping up-to-date with browser updates and authentication security rules. Vue.js claims to be "an approachable, performant and versatile framework for building web user interfaces" and in my opinion does that very well.

There are so many frameworks and it can often leave newly found coders confused as to which direction to move, but as long as you develop a very good comprehension of the big 3 frontend languages, you can't go wrong. HTML, CSS and Javascript are namely the primary languages that most frontend frameworks sit on top of. Without the former, the latter would not exist.

Yet to come...

What’s the deal with front-end developers doing developer ops work?

But this doesn’t have to be the case. Remember when you were learning to code, well the same can be done to build healthy social skills.

One great way to socialise comfortably can be to take the attention away from yourself. So, that means having questions to ask. Having a few generic questions you could ask anyone is a great way to start. And from there, fill in the gaps with more specific questions.

For example, a generic question may look like this:

• What do you feel was one thing that really challenge you so far this year?

• What was the most difficult decision you had to make this year?

• Where do you see yourself in 2 years?

• What do you do when you feel lazy?

• How do you spend your free time?

These open-ended questions are going to a) tell you the type of person someone is, and b) give you an opening to dive deeper into their response (and ultimately life). Follow up questions might look like this:

• Do you think that if you had X it would have made your decision easier?

• What is it that draws you towards that place you see yourself 2 years from now?

• Do you think there could be a better approach to X?

I love these types of questions because you will end up talking about purposeful and meaningful topics. Not only is it great for the other person to be thinking about these things, but listening to their response it will help you to find your answers to these questions. Invariably, if the other person has an interest in the conversation they will ask you the same question back. If not, do not worry if they leave you in silence. You can respond with something like:

“I really liked what you said about X and feel that it is important in my life too. What I tend to do is…”

Then go on to answer the question yourself.

Or if you didn’t agree or like their response you could say something like:

“I see that X is important in your life and its impact is benefiting you, however in my case that wouldn’t work because…”

This kind of conversation shows compassion for the other person. You don’t need to prove who is right or wrong because you are talking about subjective experiences and everyone is different.

One thing I’m working on is having conversations with people even when we both have different viewpoints and don’t agree with each other. The aim here is to understand why someone feels, thinks, or acts in a certain way rather than having a judging match of who is right.

If you are just starting to realise that you want to “get out of your shell” but do not enjoy the mainstream social places such as bars, clubs, or restaurants then another great way to meet and socialise with people is through voluntary work.

Homelessness, Shelters, and Food banks in the United Kingdom are a big deal due to the increase in utility bills and there are charities that need your help. This is a great way to be involved in an activity that is meaningful to people who need help, meanwhile building connections with those around you.

If this interests you find out more at https://streetsupport.net/give-help/

Alternatively, have a think and google the type of charity or group activity you would like to be involved in.

Good luck!

In a couple of years you will have forgotten the little annoyances and small regret.

You will be left with two things

1. Results of any efforts you have made
2. The moments remembered

What mountain are you climbing? What peak can you see if the distance?

Maybe an avalanche is on the way; Something arriving in overwhelming quantities.

We are always moving, progressing and developing. The thing about development is that where we are now will not be where we find ourselves in a few years, or even months. It’s always a work in progress. Your life is a work in progress

Inspiring life material

• A film: All Sorts

• A magazine: ZigZag surf mag

These are thought-generating words that I have published whilst on my trip to Cape town, South Africa.

Follow along for more to come.

The Developers Mindset is an intangible force that enables a person to utilize their skills along with solution-orientated thinking to make better decisions whilst coding.

When performed correctly, it allows a developer to streamline their development time. This means you are writing code that is concise and to the point. Leaving comments and correct documentation when necessary and cleaning up those console.logs() for production.

A well-rounded developer's mindset inevitably aids one in working logically through bug fixes and even reduces the potential of future bugs or bugs that may affect other areas of an application.

Continue reading to find out some of the key skills that encompass a developer's mindset.

Key Skills For A Developer

Why Patience Is A Virtue

Patience correspondences to time. It takes time to fix bugs and development of a large codebase. Many iterations through the same code to improve the performance and reliability. Rome was not built in a day and neither will your projects. Daily consistency is better than one-off binging when it comes to developing an application. Properly plan projects (usually with pen and paper) turn out better because you've put in the time to think about design patterns and what if's before writing code. Then when you're ready to key down, the process flows because you have a "road map" to follow.

Forever Learning

As a web developer or software developer, learning is something we must accept. Just because you know Javascript doesn't mean now know every other JS library there is. Sure, you know its foundations and the syntax, but you'll still need to read the documentation and search on StackOverflow.

The day you say "I'm happy with this version of NodeJS and jQuery 1.3.0" is the day you get a shock. In this industry, programming languages are always being improved, whether it's security-lead or new functionality based on clients' demands. Even browsers have to keep up with the moving tides of programming language libraries. Keep your mind open to new ways to achieve your solution.

A good example of this is - look at code you wrote 1-year ago, I bet you have a better way of writing it today.

Mistakes will happen

No one is perfect, not even code generated by AI technology! After 5-years of web development experience, I was still learning and still making mistakes - just less often. Mistakes highlight areas you may be weak on. If you start writing down these areas then you can begin to read up on and practice strengthing these weaknesses.

Think Independently

Just because others can't be bothered to write comments in their code, doesn't mean you have to do the same. I love commenting on my code because it also acts as a way for me to check over what I've done is correct. By doing so, I always find better solutions to make my code more efficient and less verbose thus making it run quicker and easier to read/understand. Without independent thinkers, things would be the same and no new ideas would come to fruition. If you've got an idea, see if you can build it physically, or meta-physically, just build it somewhere so others can benefit from it too.

I wanted to create an app that would interact with coffee machines and so I made the idea a reality. If you want to join me on this project check it out here - https://github.com/Samuroid/coffee-machine-app/tree/master. It's been a while since I've contributed to it so I could use some fresh perspectives on it.

And there it is. The developers mindset. I was inspired to write about this since there wasn't much else on the topic and the other articles I read were larger short and inconcise. In the future, I may amend this article to include the latest information on the developers mindset.

If you remember anything from here, remember this - Mistakes will happen, You will be forever learning and Think Independently.

Last written updated on August 15th 2022. To be continued...