
## Want to play the game? [Click here to check it out](https://battleships-commander-of-the-seas.vercel.app/)
## The Mission: Why AI?

The mission was straightforward: build a fun, visually engaging web version of Battleships while maximizing the use of free AI tools. As a self-taught, hobbyist developer, I aimed to put modern Large Language Models (LLMs) and popular generative design platforms to the test, exploring their true capabilities beyond the advertisements.

![A battle scene from an existing Battleships game](battleships-online-existing-game.png)

The mission was not to build something to be popular or to attract players. There are already a great free versions of Battleships you can play, such as [this one here](https://www.calculators.org/games/battleship/). 

## The Tech Stack & Gameplay

I chose a robust, yet straightforward front end approach for reliable deployment:

- Frontend: Next.js (React), Typescript
- Styling: Tailwind CSS 
- Deployment: Vercel

![File structure and code of the project](v0-code-screenshot.png)

The gameplay was intentionally simplified: 1 Battleship (5 squares, 4 hits to sink) and 4 Destroyers (1 square, 1 hit to sink). Crucially, the core game mechanics—ship placement, alternating turns, and victory conditions—had to be perfectly coded and work flawlessly.

## The Great AI Tool Showdown

My experience with the current generation of AI design tools was mixed but I never paid. Maybe the experience on offer would be dramatically different if I was a paying customer. For the free versions, many promised automated UI generation but quickly fell short of delivering exportable, usable, and maintainable code. I divided the field into three categories:

### A. The Disappointments (Uizard, Visily, Banani, Stitch)

This group was immediately frustrating. [Uizard](https://uizard.io/) and [Visily](https://www.visily.ai/) both had poor user experiences; Uizard hid its paywall, and Visily's chat functionality was broken.

![The user interface of a battleships game](unknown-game-ui.jpeg)

[Banani](https://www.banani.co/) provided designs that simply didn't match the prompt requirements. [Stitch with Google](https://stitch.withgoogle.com/) was quick, but only exported raw HTML, which was incompatible with my React stack. The takeaway here was simple: the free version of these tools are not ready for complex, functional application generation.

### B. The Paywalls and Black Boxes (UXMagic, Loveable, Bolt)

This group showed promise but hit immediate limitations.

![UX Magic battleships game design](uxmagic-designs.png)

[UXMagic](https://uxmagic.ai/) and Loveable generated functional previews but obscured the code behind paywalls or strict usage limits. Loveable's functionality was impressive, but its output was clearly aimed at non-coders - a "no-code" black box that was unsuitable for self-hosting or professional maintenance.

![Bolt battleships game design](bolt-design.png)

[Bolt](https://bolt.new/) required a chaotic signup and login process but eventually generated a seemingly full-stack app. However, its use of React/TypeScript and a separate database meant it would require significant re-writing to host on Vercel, not a simple copy-paste job.

![Loveable battleships game design](loveble-designs.png)

These tools proved that while AI can create complex apps, they aren't designed to give the code back to the developer easily.

### C. The Clear Winner: Vercel v0

[Vercel v0](https://v0.app/) was the unequivocal winner.

- It produced the best designs and the best functionality.
- Its code output was modern best-practice Next.js, React, and TypeScript.
- It offered direct GitHub integration, allowing me to easily manage versions and add custom files.

![The ship placement page of the game using v0](v0-bug-1.png)

V0 built 95% of the initial game structure and logic straight up, which was incredibly impressive. However, the experience was still a learning curve:

- Prompt Limits: I frequently used up my daily allowance. This wasn't due to simple mistakes but because the AI needed several attempts to fix bugs, highlighting a lack of internal testing of its own generated code.
- Agentic Changes: When I asked the AI to implement state preservation, it did so perfectly, but was willing to make sweeping, structural changes that wiped out my previous manual fixes. The lesson here is paramount: Get the tool to build the app end-to-end, then immediately take the reins yourself to finish the project without further agentic changes.

### The Developer's Reality: Debugging and Maintenance

V0 successfully generated the fantastic structure (the crucial "80%"), but the AI did not create a perfect application. My biggest challenges quickly shifted from coding to fixing code.

#### The Crucial Role of LLMs (Gemini)

Once my V0 prompts ran out, Google Gemini (Pro, thanks to my employer) became my effective co-pilot:

![A screenshot of a buggy ship placement page from v0](v0-bug-2.png)

- Pinpoint Debugging: Gemini proved effective at taking complex errors, narrowing down the issue's location, and pointing out logic flaws or necessary code improvements
- Code Explanation: Any generated code I copied over, Gemini was able to explain clearly, detailing its purpose and underlying logic. This helped me deeply understand the codebase and confidently identify necessary improvements.
- Asset Creation: Gemini assisted in generating and refining the required image assets for sea tiles and ships, though—similar to V0—refining the output required persistence and careful prompting. A final shout-out goes to remove.bg and GIMP for their excellent, free image editing tools that made the assets web-ready.

### Overall Verdict: The 80% Rule

My experience tells me that that AI design tools are not replacing developers yet, but they are dramatically accelerating development.

![A battle scene from the final version built using V0](v0-battle-scene.png)

- AI gets you 80% of the way there. V0 provided the foundation, the styling, and the best-practice file structure in about an hour. Without it, the project would have taken weeks of UI/UX design and boilerplate coding.
- A coder is still required. The remaining 20% - the bug fixing, the subtle CSS improvement, the custom game logic, and debugging conflicts - required over 30 hours of focused manual work. The final solution often involved using an LLM (Gemini) to guide a human coder (me) to the solution.
- This was the most complex app I’ve ever built. The final product is robust and enjoyable, something I would not have attempted two weeks ago.

The total experience was incredibly positive, and I am very impressed with the final application I built. Gemini also wrote this blog post completing the journey from inception to documentation. Plus I didn’t spend a penny! 

ps I loved most of the landing page designs:

![Unsued landing page with battleship guns](unused-landing-page-1.png) 

![Another unused landing page design from the control room of a ship](unused-landing-page-2.png) 



Testing the Waters of Generative UI Tooling


I'm not an expert, or even that interested in cybersecurity. I know enough to know it's important. 

I've read articles documenting the ongoing, changing threats that exist in our online and digital worlds. Some state-sponsered, some not. All of it is ugly and filled with malice, or ruthlessly focused on making money, no matter the impact on victims. Either way, buckle up and be ready because they're coming for all of us sooner or later. 

With this in mind, companies of all shapes and sizes know that they have a responsibility to design a safe and secure system for their business and for their customers. Single sign-on (SSO) or multi-factor authentication (MFA) flows aim at making sure the person logging in is actually you. SSO also makes logging in easy on devices where you're signed in to that provider. That is an example of a win-win scenario for security and the user experience (UX). We need more of those. 

![Angry with something showing on their laptop screen](angry-with-laptop.jpg)

## More room for UX improvements

Win win scenarios aren't always available though. [My previous post](005-digital-darwinism-and-bad-ux) outlined how I believe the presence of poorly designed digital experiences are an indication of the amount of progress we should expect (or hope for) in the coming years, as the technology evolves and matures. I have another example to share that relates to online security:

Here is each step I have to take every time I want to log in to my [Virgin Money Cash ISA (individual savings account)](https://uk.virginmoney.com/): 

1) Navigate to the Virgin Money website.
2) Click the 'Sign In' button.
3) Choose a financial product from the menu, such as 'Savings' or 'Current Accounts.'
4) Select the appropriate radio button that corresponds to the starting digits of your sort code.
5) Enter your Customer ID.
6) Enter the specified characters (e.g., the 8th, 17th, and 21st characters) of your 24-character password.
7) Check your phone for the authentication code sent via SMS and enter it.

First off, if I know my password, why can't I submit it in its entirety? How is it any more secure to ask me to figure out the 8th, 17th and 21st character of my password? Who came up with that?! Secondly I find it peculiar that I have to work out which financial product I have in the eyes of Virgin. They have my details on their system. Why can't they work it out when I log in? What is the security advantage of having a cap on the number of characters allowed in my password? 

Should Virgin Money improve my experience, or should I adjust my expectations and sense of perspective? After all, the consequences of a breach in security, and a hostile actor gaining access to my bank account far outweighs a clunky logging in experience. 

SSO and MFA are applications of technology for the purpose of protection. Are there others we can consider? My smart phone has a camera and a fingerprint sensor. Why don't I get given the choice to 'Log in on mobile device' and have these options to prove my identity? 

Perhaps there are flaws and risks to this approach that I am unaware of. Either way, I think designers need to have more robust conversations with their security and engineering colleagues when designing secure user journeys. It's in the interest of the company and of the end user. 

![Mobile phone with Chip app on the screen](chip-savings-account.png)

I ended up leaving Virgin Money for a [Chip account](https://getchip.uk). Their app is excellent. Perhaps customers like me, voting with our feet, will be the motivating force that compels companies lagging behind on technology (usually legacy incumbents) to change their ways...



Is online security always a tradeoff with frictionless UX?


Like a staircase, progress in a given technology happens with gradual optimisations and steep, transformative breakthroughs, argues Tim Goodwin in his 2018 book, [Digital Darwinism: Survival of the fittest in the age of business disruption](https://digitaldarwinism.shop/) part one. 

It's a beautiful analogy and I think it can be applied to the development of any industry, technology or process. Web development is no exception. In fact software development have a versioning method that demonstrates this for me: vx.x.x. Think of the transformative breakthroughs as 'major versions'. v1, v2, v3. The gradual optimisations, as you might imagine, are the minor updates and patches. v2.5.4, v2.5.5, v2.5.6 and so on. 

![Mobile phone showing Google Bard](chat-gpt-bard.jpg)

Generative AI technology such as Open AI's Chat GPT was transformative for the way people find answers online by changing the technology behind search engines. We've got years of optimisations of this technology ahead. 

At a more macro level Tim Goodwin talks of new technologies and their transformative potential not being fully exploited and realised when discovered. They're bolted onto existing ways of working, as optimisations. It takes a bolder vision from a small and agile startup, to create transformations using new technology at its core. 

Uber doesn't own any taxis, Airbnb any hotels nor Facebook any media outlets. These companies transformed the industries they now dominate thanks to business models that were very different to their established competitors. 

We still have desktops, files and folders on our devices. Perhaps this is another example of bolting onto the workflows of white collor clerks the as-of-now underutilised breakthroughs that personal computers might allow. 

And then there's quantum computing...

## Room for UX improvements

The user experience of some web sites certainly make me feel like we're in the infancy of this technology. Passwords hidden in a diary and account IDs on paper communications strike me as two examples of how computers have augmented the analogue. We've got a crappy hybrid UX at this point in time. Room for improvement that can't wait for the major changes. 

I've spent too much time filling in tiny input boxes on my phone, the screen a few inches from my face to make sure there's not a typo, only to find a vague error message and all of the input fields wiped blank on submit. Please oh please only reset the inputs when it's a successful submit!

I demo this on [the 'Contact me' form of my portfolio site](https://tim-cavey-portfolio.vercel.app/#contact), with: 

```js

  useEffect(() => {
    if(submitStatus === "success") {
      nameInputRef.current!.value = "";
      emailInputRef.current!.value = "";
      messageInputRef.current!.value = "";
      newsletterInputRef.current!.checked = false;
    }
    return;
  }, [submitStatus])

```

I'm also making it clear to the user when the form is being submitted and loading, when it's successful and when there's an error. Designed so that the error that gets sent from the server can reach the end user, in case it helps them to know the next best steps to take:

```js

  return (
    <div className={classes.notificationContainer}>
      <div className={classes.flexContainer}>
        <h3>{notificationData.status} </h3>
        {notificationData.status === "Sending" && <Spinner animation="grow" variant="light" />}
        {notificationData.status === "Success!" && <div className={classes.iconContainer}><Image width={50} height={50} src={tickIcon} alt="Success"/></div>}
        {notificationData.status === "Error" && <div className={classes.iconContainer}><Image width={50} height={50} src={crossIcon} alt="Error"/></div>}
        {notificationData.message && <p>{notificationData.message}</p>}
      </div>
    </div>
  );

```

Designing a good user experience for a web contact form isn't going to change the world. If it falls into any category of progress, it would be at the minor-changes and patch level. That's OK. 

There's only a little room for further improvement in web forms. Go after it with all you've got like it's survival of the fittest. Or take a step back and design a whole new way...



Digital Darwinism and Bad UX


In response to the increasing complexity and interactivity of modern web applications (web pages evolved into web apps, one might say), single-page applications (SPAs) helped avoid the need to fetch every new section of a site from the server, at the cost of a second or two.

An SPA's server could respond to a request to their domain with a single, bare-bones HTML page and a very large bundled package of JavaScript. This script ran in the browser and created the Document Object Model (DOM) needed by the browser. With this setup, everything was readily available for rendering on the DOM, eliminating the need for further server requests. The content to be rendered depended on the state of the app.

[Angular](https://angularjs.org/) was the first popular SPA JavaScript library, followed by [React](https://react.dev/) and [Vue](https://vuejs.org/). I chose to learn React. For those unfamiliar with what React is 'under the hood,' I would recommend [this talk by Tejas Kumar](https://youtu.be/f2mMOiCSj5c?si=Lrg_G-d06Zz3u9Sa).


## Conditional Rendering

With everything residing on the client-side, both local and global states largely determined what would be rendered. For example:

```js

function MyComponent() {
    const [someBooleanState, setSomeBoolean] = useState(false);

    // Fetch some data and if successful, change the state

    if (!someBooleanState) {
        return <div>Some loading spinner</div>
    }

    return <div>Main content</div>
}
```

The snippet above is an example of a component's local state. This state is relevant only to this component and perhaps its children, but unrelated components don't need to know the state created here.

## Global State and State Management Libraries

There will be many instances where distant components need access to the same state. A global state managed in a central location and provided to the root component via a Provider is an elegant way to grant app-wide access to state. Although I haven't used global state in this example, the notification banner a user receives when they sign up for my newsletter or send me a message would be a good use case.

React's createContext function and useContext hook are a common approach. My course introduced me to [Redux](https://redux.js.org/), a third-party library serving the same purpose. I'd like to show you a few examples of the @reduxjs/toolkit package, which most of my own projects have used.

## A Redux Slice and a Redux Store

To manage state, you need a way to access and change that state. State and state changes should be consistent and lead to predictable outcomes that your app can rely on. For complex apps, it makes sense to separate bits of state into their own sections or slices. The 'createSlice' function allows us to do just that:

```js

const exampleSlice = createSlice({
    name: 'example',
    // Here we define our slice's default state:
    initialState: {
        someList: [],
    },
    // These are the functions that allow for predictable state changes:
    reducers: {
        changeSomeList: (state, action) => {
            state.someList = action.payload;
        },
    // extraReducers would go here for asynchronous operations:
    },
})
```

You can define functions that provide access to this state and other functions that allow state changes:

```js

const listSelector = (state) => {
    return state.posts.list;
}
// Our list:
const theList = useSelector(listSelector);
console.log(theList);

const { changeSomeList } = exampleSlice.actions;

const dispatch = useDispatch();
// Changing our list:
dispatch(changeSomeList([...theList, 'a list item']));

const exampleReducer = exampleSlice.reducer;
```

Exporting these functions and importing them, along with their corresponding hooks, into your components allows app-wide state changes. Well... almost.

```js
// This is the store that will host ALL state: 
const store = configureStore({
    reducer: {
        example: exampleReducer
    }
   
})
// and is passed to the root component via a Provider:
const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(
    <Provider store={store}>
        <App />
    </Provider>
);
```

Once the configuration code is complete, it's easy and quick to access and change your app's state. However, be cautious of the way React schedules re-renders and state changes. If you change the state and rely on the new state within the same function, it's best to place that logic within a useEffect hook with that state as a dependency.

## There's Always Another Way

I've primarily used Redux and this toolkit package for larger apps where global state is advantageous. However, as mentioned, React's-out-the-box Context functions offer another, perhaps more intuitive way. I plan to use this approach more often, if for no other reason than it being a fresh approach.

Regardless of the approach you choose, you'll be able to avoid 'prop drilling' and repetitive code with a well-implemented global state system.








State Management with SPAs


The Dunning Kruger effect is a cognitive bias in which individuals with low abilities or knowledge in a specific field tend to overestimate their competence, while those with higher abilities or expertise may do the opposite.  [There's a great summary on Ted-Ex's YouTube here](https://youtu.be/pOLmD_WVY-E?si=F7eY9F4_9lPUtqh-).

It's the phenomenon where less skilled individuals often believe they are more skilled than they actually are, with heightened self-confidence but a lack of self-awareness, resulting in poor decision-making. This is why the process of learning to drive a vehicle is strictly guided and new starters to a company should have comprehensive inductions and ample support early on.

Here's the gist:

![The Dunning Kruger Effect](dunning-kruger-effect.svg)

To illustrate this self-perception roller coaster, I can relate it to my journey of learning JavaScript, specifically focusing on JavaScript functions.


## Functions: The Doers of JavaScript

My initial exposure to JavaScript functions was through ES6 arrow function syntax. The "=>" symbol signified a function that performed actions – it seemed simple.

```js

const exampleFunction = (parameter) => {
    console.log(parameter, this)
}

```

But there was more too it. Only after months of writing and reading JavaScript functions would that slowly reveal itself. Bit by bit, usually in the form of confusion and uncertainy. 

For instance, I now understand that the exampleFunction above is a variable expression pointing to an anonymous arrow function. Another way to define such a function would be:

```js

const exampleFunction = function (parameter) {
    console.log(parameter, this)
}

```

This is an anonymous function declaration stored as a variable expression, with different context for 'this' within that function. Another example is a function declaration:


```js

function exampleFunction (parameter) {
    console.log(parameter, this)
}

```

Not only does the context of 'this' differ from the initial arrow function, but this function name is hoisted at runtime, allowing the function declaration to be placed anywhere in the file, unlike the first two examples.

Yet another way to write an anonymous arrow function avoids the variable expression:

```js

const exampleFunction = function (parameter) {
    return () => console.log(parameter, this)
}

```

And so on...

## The Unknown Unknowns

When embarking on the journey of learning functions, it might have been the right approach to avoid diving into all the different methods and implications of writing functions comprehensively. Getting bogged down in implementation details can be counterproductive, diverting focus from grasping the core concept and its practical application.

It's perfectly acceptable for a newcomer to a subject to be unaware of the extent of what they don't know. In fact, it might be a necessary part of the learning process, allowing learners to remain largely oblivious initially and gradually revealing the nuances of the subject over time.

As the Dunning and Krugger effect shows, the learner responds to the realisation of how little they know and how much there is to learn with a sense of incompetence. The 'valley of despaire'. Perhaps learning structures should make this decline into the valley a gentle slope, to avoid any trips and tumbles that might bring the whole journey to an end. 

## Embracing a Growth Mindset

I firmly believe that adopting a 'growth mindset' can help individuals respond to drops in confidence that come with an awareness of incompetence. I find it empowering to acknowledge that I know very little about the complex world we live in, making each opportunity to learn and grow an exciting one. I try not to become defensive about my ignorance; instead, it makes it easier for me to acknowledge and celebrate small victories as I intentionally seize opportunities to enhance my understanding every day.

A person with a growth mindset embraces ignorance as a stepping stone to knowledge, rather than shying away from it or confusing ignorance with enlightenment. 

People with a growth mindset may not be immune to the Dunning Kruger effect, but their relationship between confidence and competence tends to be more linear, with fewer spikes and a shorter time horizon.








Functions and the Dunning Kruger Effect


I always remember that brown bear web page that looked like it was from the 90s.

I took an HTML course provided by [Codecademy](https://www.codecademy.com/), a popular online platform that offers interactive coding courses. The course introduced the core concepts of HTML and CSS, including a pretend web page all about bears.

I finished the course and moved on. JavaScript, along with everything else, remained an unknown unknown.

Some time later, I secured a promotion at work, which saw me take on responsibility for a high-traffic online community forum site. It was built and maintained by a software company through a software-as-a-service arrangement. They didn't need me as a developer, but I felt the need to take a second look at that brown bear web page.

![A brown bear](brown-bear.jpg)

## Codecademy Front-End Career Path

They offered more than an HTML and CSS course. They offered 'career paths.' It's a fancy name, but it consisted of several modules on a range of subjects that someone would need to know for a career in that area. 'Back end' and 'Full stack' were the other options. I stuck with the bears.

The HTML and CSS course modules were included in the career path package. I was grateful for the chance to revise it. The platform even remembered my place in each module, which, as you might imagine, tended to be the final section of every module.

## Would I recommend it?

Yes. It or something like it.

Looking back now, I'm grateful I had a structured learning journey. Being self-taught doesn't mean you have to build the curriculum. It just means you have to be honest when you mark your own work. The range of subjects and lessons was extensive. It was designed like how I imagine a coding boot camp would be, perhaps just a bit less intense and more steady.

## A comprehensive structure

It had the obvious HTML, CSS, the fundamentals of web design, JavaScript was a significant section. It also included things that might not have been obvious to a novice to learn but which are part of a common front-end web developer's workflow:

- VSCode
- Git/Github
- Browser dev tools
- Testing

It covered JavaScript libraries: React and Redux. It discussed and got us practicing coding with data structures and algorithms. I was starting to miss how simple that bears web page was. Do you recognise this classic algorithm:

```js

function sieveOfEratosthenes(limit) {
  // Create an array to track prime numbers, initialize with true
  const isPrime = Array(limit + 1).fill(true);

  // 0 and 1 are not prime, so mark them as false
  isPrime[0] = isPrime[1] = false;

  // Start with the first prime number, 2
  for (let number = 2; number * number <= limit; number++) {
    // If isPrime[number] is still true, it's a prime number
    if (isPrime[number]) {
      // Mark all multiples of the prime number as not prime
      for (let multiple = number * number; multiple <= limit; multiple += number) {
        isPrime[multiple] = false;
      }
    }
  }

  // Collect the prime numbers into an array
  const primes = [];
  for (let number = 2; number <= limit; number++) {
    if (isPrime[number]) {
      primes.push(number);
    }
  }

  return primes;
}
```

It didn't stop at coding. Compotence and technical interview questions, CV writing, the list goes on. The course structure had an aim, and that aim was to make me employable as a front-end web developer.

## Learning and Applying

The Codecademy user interface is remarkably impressive. It recreates a development environment seamlessly within your web browser, complete with a virtual browser window alongside informative text and animated, step-by-step instructions. 

This setup encouraged me to read and immediately apply what I'd learned in bite-sized portions. At the end of each module, there was a practice project (available to paid members only) – one last opportunity to reinforce my newfound knowledge before moving forward.

## Balancing Learning and Application

Perhaps my primary critique lies in the Codecademy career path's structure, which limited opportunities for hands-on practice in real-world scenarios. I learned, I executed, and perhaps revisited, but the integration of new skills by building comprehensive projects was infrequent.

I've come to appreciate the perpetual learning process in the tech world and the vital need to implement new skills after each encounter with a library, language, or framework. Now, my year is divided into weeks or months dedicated to learning and applying what I've newly acquired, an approach that has helped rectify misunderstandings and forgotten details through practical projects.

## Grateful for the Journey

As I reflect on my initial HTML course and the humble brown bears' web page, I now view it with a sense of fondness and, perhaps, a tinge of regret that it didn't initially ignite my continuous learning journey. 

It took a work promotion to rekindle my interest, but I'm genuinely grateful that it did.

Thanks [Codecademy](https://www.codecademy.com/).








Codecademy Career Path Advantages


This blog discusses various web development topics, all from the perspective of a self-taught developer. 

```js

console.log(Hello World!)

```

There's an H1 on the homepage that reads "**_Who Needs Boot Camp?_**"

It's a slightly provocative question to have as a homepage title. But with only a few words to play with, I felt the question provides the context for much of this site's content. I didn't go to a coding boost camp, I have managed to learn lots of web development and I'll be reflecting on my approaches and learning journey throughout. 

That doesn't mean I think a coding boot camp is a bad option though, so I wanted to outline my thoughts on what makes a coding bootcamp an enticing prospect to so many. 

## What Even Is A Boot Camp?

![A camp fire surrounded by campers](camp-fire.jpg)

No, not that.

A popular AI language model, which is rapidly replacing Google as my go-to for most things, described a boot camp as:

 "_An intensive, short-term training program designed to teach individuals the skills and knowledge needed to become proficient software developers. These boot camps typically focus on practical, hands-on learning and aim to prepare students for entry-level positions in the software development industry in a condensed timeframe, often spanning a few months. Boot camps cover a range of programming languages, development tools, and best practices, providing a fast track for individuals seeking to transition into a career in software development._"

They can be quite expensive, sometimes over $20k, and you either cram them into intense evenings of learning, or you're not in work while in attendance. But lots of people swear by them. Why? There are a few likely reasons:

### A Learning Structure Designed For Retention

**Tutorial hell** is when you spend an exorbitant amount of time watching videos and not practicing. When you get around to implementing things, the newly learned skills you thought you had vanish. 

There's a way to learn, and there's a way to remember what you've learned. Try it, fail or succeed, try it more than once, and try it in a slightly new way. That's how to remember something new. Explaining something to someone, even if you've only just learned it, helps you retain that information.

Both of those things are easy to NOT do when learning by yourself. Boot camps are designed so that you retain the knowledge. 

### A Community

Your instructor(s) will know their stuff. Or they're hustlers. They will tell you the latest things to learn and why. Your fellow boot campers will have their own opinions. Both will be on hand to keep you motivated, keep you from being lazy by avoiding practicing, and will be there for help and advice.

If you learn by yourself, a bunch of Discord server pals isn't quite the same. A support community is probably a big plus of boot camps.

### Job Entries

How to apply, what to apply to, when to apply, how to prepare, and maybe even putting in a good word for you. I'm guessing a bit here, but helping you to land that first job is a service often cited in boot camp marketing.

## What About A Computer Science Degree?

Being a software engineer is typically preceded by getting a degree in computer science. It's the conventional path into the industry. 

It's said that a computer science degree provides a strong foundation in the theoretical and practical aspects of computing. It equips graduates with a deep understanding of fundamental concepts, algorithms, and data structures that they can then apply to their web development roles (or at least the interview). 

Additionally, computer science programs often cover a wide range of programming languages and technologies, once again making that interview easier. 

So yes if you can afford it, if you're passionate about the subject, choosing a degree in computer science remains a great option. 

## The Self-Taught Approach

If you look at the number of web developer educators on YouTube, or their popularity in terms of views, comments, and the price some of these programmes charge, it's clear that self-learning web developers are many in number. 

Access to lots of largely free learning material, to search engines, developer forums and most recently AI language models, has made this approach a perfectly good one... in theory. 

You're somewhat on your own though. You need to be your own marker, your schedule setter, and your own coach when your confidence is down. 

Learning ineffectively, wasting time on the wrong subjects, or acquiring incorrect knowledge can be pitfalls for self-taught developers.

I'll be sharing my thoughts and reflections about this self-taught journey of mine. Hope you can join for some of it...





Who Needs Boot Camp?

Featured Posts

Testing the Waters of Generative UI Tooling

Is online security always a tradeoff with frictionless UX?

Digital Darwinism and Bad UX

State Management with SPAs

Functions and the Dunning Kruger Effect

Codecademy Career Path Advantages

The Benefits of a Coding Boot Camp

Who Needs Boot Camp?

Get an email for every new post:

Featured Posts

Testing the Waters of Generative UI Tooling

Is online security always a tradeoff with frictionless UX?

Digital Darwinism and Bad UX

State Management with SPAs

Functions and the Dunning Kruger Effect

Codecademy Career Path Advantages

The Benefits of a Coding Boot Camp