Bishop Knowledge Library

Europe

I have been talking to lab directors and managers about their challenges. Why can innovation still be slow in the age of AI? What are the biggest issues their teams face? What makes their life harder? I've noticed the same thing again and again: the real bottleneck is rarely the science. It's everything around it.
At Bishop &amp; Co., my job is to understand the deep, often unglamorous challenges a lab is wrestling with, and then work out how we can actually help. The pattern I keep seeing is this: improving assay generation increases productivity, automating a workflow improves efficiency, but treating and optimising labs as a complete holistic operation improves the entire business.
Let me walk you through what that shift actually looks like.
/.../
 
<h3>From manual workflow to intelligent workflow</h3>
Most of the labs we work with and talk to produce a lot of data, while their workflows are still optimised for paper:&nbsp;
<ul>
 <li>Sample and result logging by hand&nbsp;</li>
 <li>Printing and then re-digitising spreadsheets that only one person really understands</li>
 <li>Manually planning sample placements</li>
 <li>SOP sign-offs on paper that have to be physically chased down.</li>
</ul>
I want to be clear: none of that is a failure of the scientists. It's just accumulated habit. But every one of those manual steps is friction standing between a scientist and the actual science. When you replace them with integrated systems (a Laboratory Information Management System, Laboratory Notebooks, automated workflows), the non-scientific work shrinks, and the people you hired for their expertise get to spend their time on the work they do best.
The trick behind intelligent workflows is understanding the processes in your lab and breaking them into smaller pieces that aren't tied to a single hyper-specific use case, so the same building blocks can be reused to digitise one process after another, rather than building unique workflows one by one.
Digitalisation isn't about making the lab feel more "high-tech". It's about removing friction from the tasks that were never the point.
 
<h3>From data collection to data intelligence</h3>
As I said above, labs can drown in data and starve for insight. They generate enormous volumes of it, structured and unstructured, and most of it lands somewhere it will never be looked at again.
Today the value lies in what you do with your data, once you've got it. This is where custom software made for you and your team's exact workflow can help.
With the right solution, you can:
<ul>
 <li>Capture each result at the source with a complete audit trail, so the record never depends on someone transcribing and checking measurements by hand. When an auditor asks, every entry is already defensible.</li>
 <li>Connect your records in one platform instead of scattered spreadsheets, so results can be linked across studies, trends surfaced, and anomalies flagged automatically.</li>
 <li>Get insight to the people who need it through automated reporting and live dashboards, so a decision that used to wait days for a manual report can happen the moment the data lands.</li>
</ul>
When labs make this jump, they can stop treating data as a problem to sort out and start seeing it as an asset. And it can be done without increasing error rates as volume climbs, as long as the digital foundations underneath (standardisation, workflow orchestration, automated validation checkpoints) are solid. Volume without chaos.
 
<h3>From busy scientists to an empowered team</h3>
I'd be glossing over the hardest part if I skipped this one. Almost every automation conversation eventually hits the same nerve: the quiet fear that this is really about replacing people, or stripping scientists of their autonomy.
I understand where it comes from, and I never wave it away. But it's the wrong way round. The way I put it to teams is simple: automation handles the repetition, AI handles the pattern recognition, and scientists handle the judgement. Automation can't replace domain expertise and human judgement, but it can create more space and time for it.
 
<h3>From fragmented tools to one connected lab</h3>
So far, everything I've described still happens in separate pieces: a better workflow here, cleaner data there. However, the biggest impact appears when those pieces stop being separate. Most labs run on a patchwork of disconnected tools, and every gap between them is where time and money leak out, and mistakes seep in. When you join those workflows into one connected system, you stop managing the lab as a pile of tasks and start running it as a single, coordinated operation. The lab keeps its own workflows instead of adjusting to a tool, and ends up with one connected system rather than another tool to maintain.
This is where custom software earns its place. Off-the-shelf tools force a lab to bend its process to fit whatever the product assumes, and the gaps between those products quietly become someone's manual job. We build the other way round: software shaped around the way a lab already works, connected to every instrument, system, and third-party app the team relies on.
That's the real shift: from digitising a few forms to running a connected lab. It's the difference between a lab that is simply busy and one that creates impact.
/.../
<h2 style="text-align: center">Final Thoughts</h2>
The labs that get the most from digitalisation are the ones that stop treating it as a handful of separate tools and start designing their operation as one connected system.
That's the conversation I love having with the labs I work with, because the wins are hiding in plain sight. If yours is busy but somehow never quite fast enough, the answer probably isn't another point solution. It's a better-connected lab.

Why is your lab always busy, yet never quite fast enough? The bottleneck is rarely the science. Let me share my experience and industry insight on building connected labs.

Why Connected Labs Get More Done

<h1 style="text-align: center">Introduction</h1>
When generative AI first emerged, I approached it with scepticism. As a backend developer with years of experience, I valued the craft of writing code and was reluctant to delegate any part of it to an algorithm.
Fast forward to today, and my workflow has transformed dramatically. I now instinctively launch Perplexity or Claude alongside my IDE as a part of my development setup, or I simply use Copilot plugins or IDEs that are already integrated with them.
It’s 2026, and AI has fundamentally changed software development practices across the industry. What began as experimental tools has evolved into essential components of the modern developer’s toolkit. In this post, I’ll share insights from my journey working alongside AI and how it’s reshaping both my personal projects and professional development.
/.../
<h1 style="text-align: center">Overview</h1>
<ul>
 <li>The Rise of AI Co-pilots - My first experience with GitHub Copilot and other AI coding assistants
 <ul>
 <li>AI in the Workplace - How different organisational contexts shape AI adoption
 <ul>
 <li>Corporate Banking - The unique limitations I faced using AI in highly regulated environments</li>
 <li>Small-Scale Projects - Where AI truly shines and transforms development workflows</li>
 <li>Bridging the Gap - How organisations of different sizes can leverage AI effectively</li>
 </ul>
 </li>
 <li>From Search Engines to AI - How AI is changing how we find and apply development knowledge</li>
 </ul>
 </li>
 <li>Navigating the AI-Assisted Development Landscape - My personal guidelines for maintaining quality and ownership
 <ul>
 <li>Ownership and Responsibility - Taking full accountability for AI-generated code</li>
 <li>The Art of AI Whispering - Crafting effective prompts for better results</li>
 <li>Review, Review and Review Again - The importance of thorough code inspection</li>
 <li>Leveraging AI for Learning - Using AI to expand your knowledge and skills</li>
 <li>Resisting the Siren Song of Auto-Accept - Avoiding the pitfalls of blind acceptance</li>
 <li>Keeping my Coding Muscles Strong - Maintaining core skills in the AI era</li>
 </ul>
 </li>
 <li>Conclusion: Finding Balance in the AI Era - Final thoughts on the human-AI partnership</li>
</ul>
/.../
<h1 style="text-align: center">The Rise of AI Co-pilots</h1>
<img src="https://res.cloudinary.com/bishop-co/image/upload/v1771336142/Blog/AI%20as%20Coding%20Partner/4b7bdf7a-9a6a-4fd1-b0fc-8609243d4678_dbgyda.png" width="1428" height="583" />
GitHub Copilot - Cursor IDE - Amazon Q
I ventured into the realm of AI coding tools with low expectations. I started by tossing questions at ChatGPT whenever I hit a wall in my Java backend work. While it sometimes came through with helpful solutions, I quickly bumped into its limitations. The narrow context windows and knowledge cutoff (which was back in September 2021 when I first started using it) meant it often drew a blank when I asked about newer technologies and solutions. Whether I was curious about recent Java features, the latest Spring updates, or trending cloud-native patterns, I’d frequently get that familiar “I’m sorry, but my training data only goes up to…” response. It was like having a coding buddy who’d been living under a rock since 2021—enthusiastic but perpetually behind on what’s happening in the dev world.&nbsp;
The real eye-opener came when I installed GitHub Copilot. That first moment when it auto-completed an entire method body based solely on my descriptive method name felt like magic—I remember watching in amazement as it generated a complete implementation that handled all the edge cases I would have coded manually. The suggestions were sometimes uncannily accurate, as if it was reading my mind rather than my code.
But Copilot had its challenges, too. Its context awareness rarely extended beyond the file I was currently editing. When working on complex Java micro-services with multiple interconnected components, it would suggest implementations that contradicted patterns established elsewhere in the project.&nbsp;
Since then, I’ve explored various AI coding assistants, including Amazon Q, which truly excels when working with AWS SDK and related tools. However, the standout discovery in my journey has been Cursor—an IDE built from the ground up around AI integration. What sets Cursor apart is its flexibility to choose between different LLM models (or let it automatically select the optimal one), its impressively large context window that understands more of your codebase, and a rich array of AI-powered features that have transformed my development workflow. It’s become my go-to coding environment for bit work and personal projects.
/.../
<h2 style="text-align: center">AI in the Workplace</h2>
The application of AI tools in software development varies significantly based on organizational size and complexity. In smaller projects with standard architectures, AI assistants provide immediate value through code generation and pattern recognition. However, larger enterprise environments present unique challenges that often confuse general-purpose AI tools.
 
 
<h3>Corporate Banking: Navigating AI Limitations</h3>
Having worked in the corporate banking industry, I've experienced firsthand the limitations of leveraging AI assistants like Amazon Q or GitHub Copilot. Several factors contribute to these constraints:
<ol>
 <li style="text-align: left">Code Security: Corporate codebases are highly secured, and integrating external AI assistants into IDEs would constitute a serious security violation, even with data sharing and self-learning features disabled.</li>
 <li>Vast Domain Context: In large corporate environments, especially those using microservice architectures, the context is often too expansive for AI to work effectively. An error in one API might be caused by a different microservice with an entirely separate codebase.</li>
 <li>Proprietary Practices and Libraries: Big corporations frequently use custom-built libraries that are hidden from AI as dependencies without public documentation. They also enforce strict coding practices, from naming conventions to tabulation and testing standards.</li>
</ol>
In this context, the only way to leverage AI's power is when encountering logical roadblocks. This requires simplifying the issue to a level where only the logical solution matters, often translating complex systems (like loan management) into simplified analogies (like a grocery store inventory and checkout logic) while obscuring sensitive details.
 
 
<h3>Small-Scale projects: AI’s Playground</h3>
For smaller projects or companies with less sensitive code and reliance on public libraries, AI can truly flourish:
<ul>
 <li>Smaller codebases often fit entirely within the context window of modern co-pilots, allowing for more comprehensive assistance.</li>
 <li>Public libraries and common architectural patterns are well-understood by AI, leading to more accurate suggestions.</li>
</ul>
However, caution is still necessary. I always recommend disabling the “Share conversations with AI provider” option (or its equivalent) to prevent accidental leakage of sensitive information like environment variables.
 
 
<h3>Bridging the Gap</h3>
This disparity highlights a growing advantage for larger organizations that can invest in customizing AI tools for their specific environments. They have the resources to train AI models on their proprietary codebases and practices, potentially overcoming many of the limitations I’ve experienced.
Smaller teams, meanwhile, adapt general solutions to their specific needs. While this may seem disadvantageous, it often leads to more agile and innovative use of AI tools, as developers find creative ways to leverage AI assistance within their constraints.
In conclusion, while AI's potential in software development is immense, its application must be tailored to the specific context of each organisation. Whether in a highly secure corporate environment or a nimble startup, the key lies in understanding the strengths and limitations of AI tools and adapting their use accordingly.
/.../
<h2 style="text-align: center">From Search Engines to AI</h2>
I used to Google everything, but now I just ask my AI assistant. My search history has gone from “Java concurrent hashmap thread safety” to “good excuses for missing a standup meeting”. (a bit of developer humour there—we all know standups are sacred).
The shift is subtle but profound. Instead of scanning through multiple search results, I get a conversational answer that feels more natural. Of course, I've encountered my fair share of entertaining AI blunders—like when my assistant confidently declared that the cutting-edge UI framework I was implementing in my side project was, in fact, a specialised Linux distribution for embedded systems.
Perhaps even more significantly, AI has largely replaced my daily pilgrimages to Stack Overflow. Those marathon sessions of opening twenty browser tabs, sifting through opinionated answers (some from 2012 and before), and navigating comments like “Why would anyone do it this way?” have become increasingly rare. The sacred ritual of copying error messages, pasting them into Stack Overflow’s search bar, and praying someone encountered the same obscure issue five years ago has been supplanted by simply asking my AI buddy to diagnose the problem.
<img src="https://res.cloudinary.com/bishop-co/image/upload/v1771336142/Blog/AI%20as%20Coding%20Partner/7ced90b5-ed10-49c4-a511-002e1b15f8a4_a0z2yf.jpg" width="683" height="512" />
 
The AI doesn’t just provide answers—it offers context, explains the underlying concepts, and doesn’t include the obligatory Stack Overflow comment questioning my entire approach to software development. That said, I do occasionally miss the shared experience of seeing other developers struggling with the same issues, and the validation that comes from upvotes confirming I’m not the only one confused by a particular API. There’s something uniquely reassuring about human confusion that AI hasn’t quite replicated yet.
One game-changer has been AI’s new context grounding features. Now, when I get answers, I also see where they came from—actual documentation, articles, or repositories. This means I can verify sources and dig deeper when needed. No more mystery meat solutions! It’s reduced those “wait, that’s completely wrong” moments and built my trust in AI suggestions. It’s like having a lead dev who not only solves your problem but also drops links to the docs so you can learn why it works.
<img src="https://res.cloudinary.com/bishop-co/image/upload/v1771336142/Blog/AI%20as%20Coding%20Partner/eb91db1d-82e9-443e-824a-aa76476641ef_fqjfzc.png" width="1566" height="1216" />
<h1 style="text-align: center">Navigating the AI-assisted Development Landscape</h1>
<img src="https://res.cloudinary.com/bishop-co/image/upload/v1771336142/Blog/AI%20as%20Coding%20Partner/27a60a87-c618-49a1-aee1-f26746ea5248_i7mixr.jpg" width="551" height="453" />
 
I’ve watched AI tools steadily weave themselves into my daily coding routine, and along the way, I’ve realised how important it is to set some ground rules. Through plenty of trial and error (and a few memorable mistakes), I’ve developed personal guidelines that help me get the most from these tools while avoiding their pitfalls. These practices have become my compass for maintaining high-quality code and continuing my growth as a developer, even as I increasingly collaborate with my silicon-based friends.
 
<h3>Ownership and Responsibility</h3>
First and foremost, I always remind myself and everyone: Code written by an AI assistant is still your code. I treat AI-generated code with the same precision and attention to detail as if I had written every line myself. This mindset ensures that I maintain full responsibility for the outcome, regardless of its origin. It’s not as if I could march into my manager's office after a production incident and declare, "Don't blame me-the AI wrote that part!"
 
<h3>The Art of AI Whispering</h3>
I used to think I could just throw error messages at ChatGPT and get magical solutions. Spoiler alert: that approach leads to more confusion than code. These days, I treat writing prompts like I’m drafting a spec document. I provide context, explain what I’m trying to achieve, and outline any constraints. It’s like pair programming with a brilliant but easily confused partner - the more context you provide, the better the results.
 
<h3>Review, Review and Review Again</h3>
I’ll admit, there was a time when I’d skim AI-generated code and think, “Looks good to me!” and ship it. That approach led to some interesting debugging sessions and a few “How did this ever work?” moments. Now, I review AI suggestions with the same intensity as code written by a junior developer with a caffeine addiction. Every line gets scrutinised, and I’ve caught some subtle bugs that could have caused major headaches down the line.
 
 
<h3>Leveraging AI for Learning</h3>
When AI suggests an approach I’m unfamiliar with, I see it as a learning opportunity rather than a roadblock. I often ask the AI to explain its reasoning step-by-step, supplementing this with my own research. This practice not only expands my knowledge but also helps me critically evaluate the machine’s suggestions.
 
 
<h3>Resisting the Siren Song of Auto-Accept</h3>
The “Accept Suggestion” button in Copilot is dangerously tempting. It whispers promises of effortless coding and unmatched productivity. But I’ve learned to resist its siren song. Blindly accepting AI suggestions is a fast track to code you don’t understand and can’t maintain. Instead, I take a breath, review the suggestion, and only then decide if it’s the right fit for my project.
 
 
<h3>Keeping my Coding Muscles Strong</h3>
To make sure I don’t become overly reliant on AI, I regularly schedule “AI-free” coding sessions. It’s like going to the gym for my development skills - sometimes uncomfortable, often challenging, but ultimately necessary to stay in top coding shape. After all, you can’t exactly ask the interviewer for a quick break to consult your AI buddy when they hit you with a tricky algorithm question. “Hang on, let me just check with ChatGPT real quick”, probably won’t impress anyone in the hiring seat.&nbsp;
By adhering to these practices, I’ve found a balance that allows me to harness the power of AI assistance while continuing to grow as a developer and maintain high standards of code quality. The key lies in viewing AI as a powerful tool to augment our capabilities, rather than a replacement for our expertise and judgment.
/.../
<h1 style="text-align: center">Final thoughts</h1>
The most effective approach to AI in software development is viewing it as an amplifier for human capabilities rather than a replacement. The optimal workflow leverages AI for routine tasks, pattern implementation, and knowledge retrieval while reserving human focus for architecture, business logic, and critical decision-making.
As we continue to refine this partnership, the developers who will thrive are those who understand both the capabilities and limitations of AI assistants. By maintaining this balance, we can enhance productivity without sacrificing the depth of understanding that characterises truly exceptional software development.
The future of coding isn't human versus AI, but humans and AI working in tandem—each contributing their unique strengths to create better software more efficiently than either could alone.

Will AI make you a better developer or a lazier one? In this post, I show my journey from sceptic to daily co-pilot user, break down the tools I use, compare startup vs. corporate constraints, and share my rules for prompting and reviewing code to stay accountable and sharp.

Coding in Tandem: AI as a Coding Partner

Have you ever wondered how to secure your Spring Boot API with Auth0? In this guide, I’ll cover authentication vs. authorization, Spring Security setup, and JWT validation. You’ll learn to configure Auth0, secure endpoints, and build a scalable API with robust token security.

Using Auth0 as an Identity Provider in Spring Boot API

As a Java developer, my biggest gripe has always been speed.
To be more specific, startup speed. Starting up a Java application with all its JVM glory can take up to 10–15 seconds in a heavier application. In this day and age where the attention span of a user can be measured in mere 7–8 seconds, this can be problematic. Imagine waiting 10–12 seconds for your favorite Twitter user’s page to load.
 
Scaling Java applications can be tricky (and pricy!) in the cloud due to the nature of the ‘write once — run anywhere’ paradigm. But what if we could eliminate this cold boot issue? What if we could optimise the price we pay for our cloud infrastructure?
/.../
<h1 style="text-align: center">Introducing GraalVM native images and Quarkus</h1>
<h3>What is GraalVM, and what are native images?</h3>
<a href="https://www.graalvm.org/" rel="noopener ugc nofollow" target="_blank">GraalVM</a> is a high-performance JDK distribution. It is designed to accelerate the execution of applications written in Java and other JVM languages while also providing runtimes for JavaScript, Ruby, Python, and a number of other popular languages. It heavily relies on compiler optimisation techniques, such as an <a href="https://www.graalvm.org/java/advantages/#accelerating-java-performance" rel="noopener ugc nofollow" target="_blank">aggressive and sophisticated inlining technique</a>.
 
With GraalVM you can compile Java bytecode into a platform-specific, self-contained, native executable to achieve faster startup and smaller footprint for your application. It uses an AOT (ahead-of-time) compiler instead of the JIT one that we are used to.
 
Ahead-of-time compiled applications use only a fraction of the resources required by the JVM which means they cost less to run and improve utilisation. This means that although your application might consume significantly less memory and start up faster, you might have to wait a bit more for your compilation to complete.
<blockquote style="text-align: center">Smaller memory footprint means that our cloud infrastructure can run on cheaper, smaller instances than we would normally run them in JVM mode.</blockquote>
Natively compiled applications can also benefit from starting up from a pre-booted memory snapshot. That means that frameworks that fully support native image compilation can leverage it to create configuration at compile time instead of taking time to configure your application at startup. 
The image below shows memory usage and execution times in native mode.&nbsp;
<img src="https://res.cloudinary.com/bishop-co/image/upload/v1727877352/Blog/Java_start_up_time_pmw3xm.webp" width="1400" height="541" />
<a href="https://www.graalvm.org/native-image/" rel="noopener ugc nofollow" target="_blank">https://www.graalvm.org/native-image/</a>
There are several frameworks, such as Quarkus, Micronaut that fully support native image compilation. At the time of writing this article, the Spring team is still a little behind in fully supporting it, <a href="https://spring.io/blog/2021/03/11/announcing-spring-native-beta" rel="noopener ugc nofollow" target="_blank">but support is on its way</a>! 

It’s not all fun and games with native images. We lose a lot of convenience features that the JVM provides, such as profiling and remote debugging. 
Garbage collection is thankfully <a href="https://www.graalvm.org/22.1/reference-manual/native-image/MemoryManagement/" rel="noopener ugc nofollow" target="_blank">still an option</a> in native mode though!
 
<h3>How to install GraalVM and native image extension</h3>
You can install GraalVM on your machine in several ways.
<ul>
 <li>You can download the official releases from their <a href="https://github.com/graalvm/graalvm-ce-builds/releases" rel="noopener ugc nofollow" target="_blank">GitHub</a> page. They support several platforms (including Apple Silicon!) and two versions of Java. After that, you can follow <a href="https://www.graalvm.org/22.1/docs/getting-started/#install-graalvm" rel="noopener ugc nofollow" target="_blank">this guide</a> for your respective platform.</li>
 <li>Another option if you have a UNIX-like system, like Linux or MacOS, is to use SDKMan to manage your installed SKDs. It’s a great tool to manage multiple java installations and switch between them with ease. Think of this tool as <a href="https://github.com/nvm-sh/nvm" rel="noopener ugc nofollow" target="_blank">NVM</a> for Java. Follow <a href="https://sdkman.io/" rel="noopener ugc nofollow" target="_blank">this link</a> to learn more about SDKMan and about how to install it.</li>
</ul>
 
<h1 style="text-align: center">The Quarkus framework</h1>
 
<h3>What is Quarkus?</h3>
A Kubernetes Native Java stack tailored for OpenJDK HotSpot and GraalVM, crafted from the best-of-breed Java libraries and standards. It encapsulates a load of features that make it really cool to develop with it.
<ul>
 <li>Container First: Quarkus tailors your application for GraalVM and HotSpot. Amazingly fast boot time, incredibly low RSS memory (not just heap size!) offering near-instant scale-up and high-density memory utilization in container orchestration platforms like Kubernetes. They use a technique we call compile time boot, which is leveraged by using GraalVM’s native image module.</li>
 <li>Unifies imperative and reactive approaches: Combine both the familiar imperative code and the reactive style when developing applications.</li>
 <li>Community and Standards: Quarkus provides a cohesive, fun-to-use, full-stack framework by leveraging a growing list of over fifty best-of-breed libraries that you love and use. All are wired on a standard backbone.</li>
 <li>Kube-Native: The combination of Quarkus and Kubernetes provides an ideal environment for creating scalable, fast, and lightweight applications. Quarkus significantly increases developer productivity with tooling, pre-built integrations, application services, and more.</li>
 <li>Developer Joy: A cohesive platform for optimized developer joy with unified configuration and no-hassle native executable generation. Zero config, live reload in the blink of an eye. It also has integrated support for <a href="https://www.testcontainers.org/" rel="noopener ugc nofollow" target="_blank">Testcontainers</a>, which starts up relevant containers for you during development.</li>
</ul>
Quarkus also offers amazing performance both with GraalVM JVM and native image mode as well. The image below shows memory usage and time-to-first response graphs both in JVM and native mode.
<img src="https://res.cloudinary.com/bishop-co/image/upload/v1727877352/Blog/memory_usage_k38q2u.webp" width="1400" height="644" />
<a href="https://quarkus.io/" rel="noopener ugc nofollow" target="_blank">https://quarkus.io</a>
 
<h3>A simple Quarkus application</h3>
Getting started with Quarkus is a similar experience to using SpringBoot. It has a similar process of creating a new application from scratch. Let’s create a simple application with a REST controller which we can compile to native later!
 
The first step is to visit <a href="https://code.quarkus.io/" rel="noopener ugc nofollow" target="_blank">https://code.quarkus.io</a> . This page presents us with a similar interface to <a href="https://start.spring.io/" rel="noopener ugc nofollow" target="_blank">https://start.spring.io</a>. You can select your desired build tool and java version. There is also a Kotlin extension if f that’s what floats your boat. For now, the default configuration is fine for us.
 
Select <code>RESTEasy Reactive</code> and <code>RESTEasy Reactive Jackson</code>` extensions and click Generate your application. This should create and download a zip package with our generated source code.
Unzip, navigate to the folder and issue the <code>./mvnw compile quarkus:dev</code> command to start our application on development mode with live reload. Let's visit <a href="http://localhost:8080/hello]and" rel="noopener ugc nofollow" target="_blank">http://localhost:8080/hello</a> and make sure it works.
 
You might have noticed it almost took a second for the application to start up in JVM mode under GraalVM. This is unacceptable 😤. Let’s compile it into a native imageQuarkus JVM startup time.
<img src="https://res.cloudinary.com/bishop-co/image/upload/v1727877352/Blog/Quarkus_JVM_startup_time._ajpodp.webp" width="1400" height="219" />
Quarkus JVM startup time.
<h3>Compiling to native</h3>
You have two ways of compiling into native images.
<ul>
 <li>If you have &nbsp;GraalVM &nbsp;installed and the native image extension, you can run the following command to compile a native image: <code>./mvnw package -Pnative</code></li>
 <li>If you have not installed it on your own machine, you also have the option to use a D<a href="https://www.docker.com/" rel="noopener ugc nofollow" target="_blank">ocker</a> container that has GraalVM and the native image extension installed by default. You can use the following command for that: <code>./mvnw package -Pnative -Dquarkus.native.container-build=true</code></li>
</ul>
It might take some time to finish compilation, especially in the docker container, but after a while you should have a native executable named <code>code-with-quarkus-1.0.0.-SNAPSHOT-runner</code> in your target folder.
 
<blockquote style="text-align: center">Now it started up in a matter of a couple of milliseconds. Nice!</blockquote>
 
<img src="https://res.cloudinary.com/bishop-co/image/upload/v1727877352/Blog/Quarkus_native_startup_time_hh9yhc.webp" width="1400" height="172" />
Quarkus native startup time
/.../
<h1 style="text-align: center">Final thoughts</h1>
So there you have it. Now you can compile Quarkus applications into native images. Hopefully, this article was a helpful intro to native images and Quarkus!
If you find this helpful, share it, so others can learn from it as well!

Struggling with slow Java app startups? In this guide, I’ll show you how GraalVM and Quarkus can help. GraalVM compiles Java into fast native executables, while Quarkus optimizes for scalability. I’ll walk you through setting up GraalVM and building a Quarkus app into a native image!

Native Images and Quarkus: JVM-less Java

Starting a new career or job is never easy, but that’s especially true in the field of IT. There’s no one-size-fits-all recipe for success and learning; each career path is different from the next. There are hundreds of courses, tutorials, and blogs with conflicting information. No wonder you sometimes feel lost.
As a junior backend developer, I thought I would help you out by sharing some advice I wish I had had when I started my journey. I hope you’ll find them helpful.
/.../
<h3>You only learn by doing:</h3>
When you learn a new piece of information, the easiest way to understand it is by doing it. For example: you may think that you can write a for loop, but in practice, you might struggle with it. 
In short: Put the theory into practice!
<h3>You won’t know everything:</h3>
As a junior developer, you can’t/ don’t need to know everything, so don’t stress. In this profession, you need to learn and polish your skills because this world is constantly changing and evolving.
Focus on being a lifelong learner and a proactive part of the team.
<h3>Github:</h3>
Create a Github account and publish your practice or active projects. This way, you can get to know the Git version control system and your (future) colleagues can see what you’re interested in.
<h3>Don't be afraid to write bad code:</h3>
It might sound weird at first, but in real life, usually, your first version of a code won’t be perfect. Firstly, try to solve the problem, and then you can improve the quality of your code. Create a code that others can read and understand easily, like a good poem.
<h3>Joint project:</h3>
It can be really beneficial if you are able to work on a bigger, and more long-term project with your friends/ classmates. It’s a great work experience, you can learn to work in a team setting, which will be indispensable in the long run.
<h3>Practice, practice, practice:</h3>
Besides learning new things and keeping up with new technologies, you should revise your skills and knowledge. You might forget more than you realize.
<h3>Rest:</h3>
If you are sitting for hours on a problem, but you can’t seem to solve it, or you get lost in it, it’s time to take a break. Try to remove yourself from the problem, have a coffee, get some fresh air or chat with some friends, so your brain can relax and regroup your focus and energy.
<h3>Ask!</h3>
If you aren’t able to solve something, don’t be afraid and ask! As a Junior, you don’t need to know everything, and it’s better to get help than to be stuck on an issue for ages.
There is an effect called: Rubber duck debugging. You might understand and solve the problem while telling someone else. Your brain is forced to organize the information in a new way. This might clear up things in your head (it happened to me on multiple occasions).
 
<blockquote style="text-align: center">Long story short: ask, because you’ll only get better.</blockquote>
<h3>Improve your English:</h3>
In most companies, it’s an expectation to read and write in English on a conversational level. You can work on an international project, but you need to communicate with others, besides this, as you can see, you’ll find most resources in English.
 
<h3>Useful resources:</h3>
<ul>
 <li>You can find a solution to pretty much everything here: <a href="https://stackoverflow.com/" rel="noopener ugc nofollow" target="_blank">stackoverflow.com</a></li>
 <li>If you want to work with JAVA in Spring Boot framework: <a href="https://www.baeldung.com/" rel="noopener ugc nofollow" target="_blank">baeldung.com</a></li>
 <li>Practice exercises for different skill levels: <a href="https://www.hackerrank.com/" rel="noopener ugc nofollow" target="_blank">hackerrank.com</a>, and <a href="https://leetcode.com/" rel="noopener ugc nofollow" target="_blank">leetcode.com</a></li>
 <li>+1 Best Hungarian YouTube channel (Spring Boot, Git, JAVA, Docker, tips for job interviews, and a lot more…) <a href="https://www.youtube.com/c/SanFranciscobolJottem" rel="noopener ugc nofollow" target="_blank">youtube.com/c/SanFranciscobolJottem</a></li>
</ul>
/.../
<h1 style="text-align: center">Final thoughts</h1>
I hope you enjoyed reading this and found the tips helpful. Starting a career in IT, especially as a junior developer, can feel overwhelming, but remember, you’re not alone on this journey. We all have to start somewhere, and the most important thing is to stay curious, keep practising, and never stop learning!

Starting a career in IT can be overwhelming, especially for junior developers. From navigating conflicting resources to overcoming the fear of writing bad code, you have to face a lot of challenges. In this post, I share tips based on my own experiences, that helped me at the start of my career.

Bishop Knowledge Library

Latest articles