Forem: Jack 'eXit' Whitter-Jones

Week 9 - Trial and Error

Jack 'eXit' Whitter-Jones — Fri, 01 Jul 2022 13:23:22 +0000

A week late, but none the less, life has a way!

This will be a short post, just explaining the key findings that I have achieved.

Lessons Learnt

One of the key things I found is the interaction with external APIs. The initial few days, were focused on reading over the documentation and the APIs.

Using the fetchwrapper taken from the JS tutorials, the GET API was the major focus on this. However, extracting a bunch of data all in one go has its limitations and requires proper polling.

Having saved all the data into separate files the next step is to begin to look at visualising the data.

Next Steps

While the interaction with external APIs has been quite fun. I think the visualisation of the data is the next key step to compound my initial JS learning. In addition, I believe a review of data structures and algorithms maybe helpful.

Wrap-up

Thank you for checking up on my progress and I hope to provide some more interesting work in the next few weeks.

Jack/eXit

Week 6, 7, and 8 - The DOM, the extras, and the wrap up

Jack 'eXit' Whitter-Jones — Sun, 19 Jun 2022 17:42:29 +0000

The combination of the last three weeks into one blog post comes from a lack of time to write a cohesive blog post that is enjoyable to read! Over the course of these last three weeks, I have maintained my journal and my daily revision structure. This post will combine the notes and key areas of development conducted over the last three weeks worth of learning.

The main resources used are:

Main Resource - LearnJavaScript.online

What Was Learnt

This post looks at two parts, the DOM and async/await.

The DOM

The DOM or Document Object Model is by far one of the most critical components of Web Development. The browser uses the DOM to provide a hierarchy of components that render onto the page. Similar to that of the prototype structure, the hierarchy builds a functional web-page based on the HTML, CSS, and JavaScript that has been applied.

From the Learn JavaScript resource, one of the major components that a JS developer has to navigate is how to acquire certain components from the webpage. For example:

<h1 id="my-header">Hello</h1>

To acquire this tag a JS developer would use the following function:

const myHeader = document.querySelector("#my-header");

Firstly, the JS developer accesses the global document object, that contains almost all the content on the page (the exception is the shadow DOM). The querySelector function then searches the web-page for any id with the name "my-header", alternatively, we can find all ids with a name using the document.querySelectorAll.

Now we can access the properties that the header has, for example, the text that the header is holding:

console.log(myHeader.textContent) // Hello

By being able to access multiple different components we can then add varying functionality, such as event-based functionality.

myHeader.addEventListener("click", () => {
    myHeader.textContent = "Hello World!";
});

By adding an event to the component we can have dynamic functionality based on the characteristics of events, such as:

Click
Submit
Change

The DOM is a huge topic and one can dedicate a lot of time to understand how it works, one great resource for delving deeper into the area is W3.org DOM

Async/Await

With the previous post provided an overview of JS Promises. Async/Await provides syntactic sugar, a phrase that basically means a short-cut for writing JS Promises by abstracting away from the minutiae of the topic. The following is a basic transition from Promises to Async:

Promises

// Promises
const getWebsite = () => {
    fetch("fakeSite").then(response => response.json()).then(data => console.log(data))
}

Async/Await

const getWebsite = async () => {
     const response = await fetch("fakeSite);
     const data = await response.json();
     console.log(data);
}

The only difference in this case is that Async/Await provides a succinct more readable method of writing such a function. However, it does come down mostly to preference. Some developers prefer the chaining of conditions together via the Promises, and others prefer the use of async/await with the addition of try-catch statements to manage the errors that maybe produced.

I will state, the Learn JavaScript makes a great emphasis on the fact that any developer should have a solid grasp of Promises before diving into Async/await due to them being as we said, syntactic sugar of promises.

Resource Review

Having started Learn JavaScript on the 6th of May 2022, I have finally completed the 78 section course on the 19th of June 2022. Over the course of the 45days, I feel this course has provided me a great advantage over many resources due to its compounding learning approach, while maintaining a good level of ease to digest writing and detailed knowledge around the topic.

The flashcard functionality provides a great method for pre-sleep revision to ensure that you understand key concepts to hit that spaced-repetition!

I would encourage anyone to consider using this resource to learn JavaScript as there first entry into the language as it provides a well structured, succinct, and unique approach to developing good practice and understanding.

Sign Off

Going forward, the next step is to spend a week practicing the skills learnt throughout this last 45 days. The project will be carried out using the following rough structure:

Day 1: Brainstorm and plan the project
Day 2: Drawn design of the application
Day 3: Strawman the application
Day 4: Visualise the data
Day 5: Tidy and Review
Day 6: Break
Day 7: Write-Up

Obviously this structure is a rough draft to work with and has fluidity to it, as potential areas may require more time to work with or may be completed earlier.

This has been a really fun 45 days, I look forward to seeing you all in 7 days!

Jack/eXit

Week 5 - Promises, promises, promises

Jack 'eXit' Whitter-Jones — Sun, 29 May 2022 19:46:18 +0000

API communication is the pivotal point in how websites communicate between each other and this is where JavaScript shines. This blog post delves into how JavaScript works through the use of Promises, and Fetch.

The main resources used are:

Main Resource - LearnJavaScript.online

What Was Learnt

Promises have been the main stay of my weeks revision, along with the fetch function.

Promises provide the functionality to achieve asynchronous communication between clients and servers. When a client and server talk, the communication stream can take a period of time to respond. With this being the case, synchronous communication begins to fall down as it blocks or in other words freeze the application.

Asynchronous programming enables applications to be non-blocking, that allows the application to continue processing, but also allows for communicating between a client and server in the background. Promises are the key to making this work.

Promises object within JavaScript allows communications between client and servers to share data between one another. A client connects to a server through a URL. The server returns a promise, ensuring that the client and server share communication stream but allow for a period of time for data to be sent. The following code example demonstrates how an API function might return a Promise when it has been contacted by a client:

function getMyAPI(ip){
    return new Promise((resolve, reject) => {
           if(ip === "127.0.0.1"){
                reject("No local host addresses please...");
           }
           resolve({
                msg: "Yay you got my message...";
           });
    })
}

The outcome of this code example can be split into three stages:

Pending - The state that is used when communication is being conducted
Fulfilled - When the communication is complete, even if there is a 404
Rejected - Communication has been failed, perhaps through network issues

The resolve function provides a fulfilled state to the promise, this is where data is typically sent back in JSON format.

The reject function provides an error for the communication stream so that developers can handle the outcome.

By now, this should remind you of another type of functionality, the try-catch structure.

try {
   // handle success
} catch {
   // handle error
}

To handle the promise that an API returns, we can use the follow code example:

    fetch("fakeSite").then(response => response.json()).then(data => console.log(data)).catch(error => console.log(error));

In this example, a promise is returned by the fetch function, which is handle by the then function. This handles the response from the API. The .json() part of the function itself returns another promise, which we can use the .then function again to handle the data. Finally, the .catch handles any errors asynchronously preventing the application from blocking.

Finally, to handle the data of the second then we should consider passing the data to a function, in this case we have used console.log but we can send it to a database for example. The reason we do this, is because the data does not live outside the scope of the then function.

One of the key findings of this weeks learning has been the interaction of asynchronous coding style. One key importance of using async code is to ensure that all code is asynchronous throughout the life span of that function. If not, the application will become blocking, and slow down the speed and performance of the application.

Resource Review

LearnJavaScript has been an excellent resource for learning this important concept. LearnJavaScript has been able to explain the concept through step-by-step approach that builds each lesson. One of the most important concept for learning promises has been the comparison to try catch structure. A typically hard concept for many, LearnJavaScripts step-by-step breakdown of the concept in suitable components.

Retrospective

The promise and fetch execution has been an interesting topic. For learning this functionality, it is worth building fake API functionality, or even to interlinking with third-party APIs to get a wider understanding of the process. Additionally, it is also quite fun to capture the traffic within Wireshark to understand the networking side of HTTP.

Over the next week I will try to apply third-party interaction to compound the learning that has been done so far.

Sign Off

It has been a turning point over the course of the week and has highlighted how proficient JavaScript can be.

Until next week!

Jack/eXit

Week 4 - Class is in session

Jack 'eXit' Whitter-Jones — Sun, 22 May 2022 20:35:31 +0000

Within many programming languages, classes are the a common concept due to Object Orientated Programming being the dominant paradigm.

JavaScript is no different to other programming languages with its support of classes, however, its implementation of classes IS very different, which we will explore.

Following the previous posts, the main resource and supplementary resources are shown below, and are discussed at the latter end of the post.

Main Resource - LearnJavaScript.online
Supplementary Resource #1 - StackOverflow Classical Inheritence vs Prototype Inheritence
Supplementary Resource #2 - MDN JavaScript Classes

What Was Learnt

JavaScript has a variety of ways of programming, procedural, functional, and object-orientated.

Within JavaScript, object-orientated programming is developed through the creation of objects, which is achieved through the use of the curly bracer, as follows:

const myObject = {
    name: "Jack/eXit",
    language: "JavaScript"
};

The remainder of this blog post focuses on the Object Orientated Programming implementation of JavaScript.

Classes

However, the example above only provides us with a collection of data, instead we can create a more sophisticated version which has both data and functionality.

class Computer{
    constructor(name){
         this.name = name;
    }

    set name(value){
        this._name = value;
    }

    get name(){
        return `This is a ${this._name} computer`;
    }

    turnOn(){
       console.log("Turning on.... beep boop!");
    }

}

const myComputer = new Computer("Apple");
console.log(myComputer.name);
myComputer.turnOn();

This example has alot going on in it, and will be broken down in the following sections.

Constructors

Within a class, a constructor is a way of binding user or computer supplied content to a class, for example, a persons name, character id, character level, postal address, bank number, etc.

Within the example, the constructor takes the data of name, in this case, "Apple" and supplies it to the classes field, referred to as "this.name". We use "this" in a class to refer to the object. This is important when we have multiple versions of the class, also referred to as instantiated objects of class Computer.

Getters and Setters

Getters and Setters are a great way of managing content within a class, along with constructors, as they help us manage data that is being set.

For example, if we have a value being set, e.g., an age. We might allow a user to set the name via a string or via a number. However, the setter can be used to parse the string into a number so that we remove any issues of using a string instead of a number.

The Getters also provide us a great way of returning data. Sometimes we might want to format the content that is being returned, like what was done in this example. Instead of returning just the string, we can also return some following text.

Methods

Methods provide our behaviour to our attributes (data). A method is just a Object Orientated Programming term for function. In this instance, we are using methods (functions) to give the class some behaviour that the user of the class can interact with. For example, because we are creating a class of Computer, we want to give it the behaviour of turning on. The method only prints a sentence out, however, it provides some dynamism to our objects in the future. If we wanted we could add a method for it to become sentient... but we shouldn't do that just yet!!!

Inheritance

To provide further functionality so that we dont have to reinvent the wheel, JavaScript allows us to extend the class further, allowing us to define a computer, as well as sub-classes of computer, for example, mobile phones.

class Computer{
    constructor(name){
         this.name = name;
    }

    set name(value){
        this._name = value;
    }

    get name(){
        return `This is a ${this._name} computer`;
    }

    turnOn(){
       console.log("Turning on.... beep boop!");
    }

}

class Mobile extends Computer{
    constructor(name, type){
        super(name);
        this.type = type;
    }

    callSomeone(){
        console.log("Calling home to the mothership...");
    }
}

const myComputer = new Computer("Apple");
console.log(myComputer.name);
myComputer.turnOn();

const myMobile = new Mobile("eXits Phone", "Android");
myMobile.callSomeone();

This example extends the class of Computer by using the "extend" keyword. With this, we are able to Inherit the attributes and behaviours of the inherited class or parent class.

Within the constructor of mobile, we can define new attributes such as the type of phone as shown via:

this.type = type;

but we can also use the "super" keyword:

super(name);

The "super" keyword is important as it allows us to inherit the attributes of the parent class, but also allows a developer to pass data back into the parent class, to reduce the amount of typing your fingers have to do!

HOWEVER while we see classes and the inheritance of its parent class via the extend keyword, the class functionality actually boils back to a function. This is what is called syntactic sugar, a term, which means that it makes life easier for us as developers to write and manage our code!!!

The next section discusses further the purpose of why class and extend are considered "syntactic sugar" and how the extend keyword truly inherits its parents behaviours and attributes.

Prototype

As the introduction to this post discusses, JavaScript implements classes slightly differently to other languages. This is down to the Prototype Chain, which is how classes inherit from one another.

Within every object, is a Prototype chain, which indicates the previous object that the current object inherits from, all the way back to the start of the chain, which will be the type null.

The image below, demonstrates the direction JavaScript reads a Prototype Chain (black arrows). From left to right, our classes we have defined in this blog post are illustrated in green, where the built in types are purple, going back to the Prototype type shown in red, and then terminating in the null type shown in grey.

This is importance to understand as we can then verify the process by using the built in function Object.getPrototypeOf();.

Using the above code (including the mobile class), we can output the following Prototype Chain to verify our diagram:

console.log(myMobile); // Mobile
console.log(Object.getPrototypeOf(myMobile)); // Computer
console.log(Object.getPrototypeOf(Object.getPrototypeOf(myMobile))); // Object
console.log(Object.getPrototypeOf(Object.getPrototypeOf(Object.getPrototypeOf(myMobile)))); // Prototype
console.log(Object.getPrototypeOf(Object.getPrototypeOf(Object.getPrototypeOf(Object.getPrototypeOf(myMobile))))); // null

By chaining our Prototypes together, JavaScript can create a very complex inheritance chain, as illustrated below, whereby each object inherits from its parent type and has its functionality as shown via the red lines allowing the object to access any method of behaviour its parents has without having to call the previous object directly.

Further Theory

The theory behind of why JavaScript use Prototype-based inheritance is to manage the classical inheritance problem, which can be confusing to understand, however, this StackOverflow post elaborates further, which I urge you to read.

Resource Review

The LearnJavaScript.online resource has been a great way of understanding the Object Orientated Programming paradigm from a JavaScript perspective. However, it is definitely worth supplementing the content with a wider reading around the theory of Classical Inheritance vs Prototype Inheritance just to understand what problem JavaScript is trying to solve in this instance.

From further research, the supplementary StackOverflow post provides a clear comparison between the two theories and I strongly urge anyone to read it.

Retrospective

This weeks learning has been a lot of fun, It has definitely made me really understand the topic of inheritance more not only in JavaScript but also other languages like Java or C#. Therefore, I think graphical representations of different concepts are worth investing in.

Sign Off

Thank you for reading this weeks post, this has been a really fun week!

Feel free to leave a comment if there is anything I have miss-typed or could try and simplify as it is a great way for me to compound my learning!

See you all next week :)

Jack/eXit

Week 3 - Array of Objects

Jack 'eXit' Whitter-Jones — Sun, 15 May 2022 17:40:24 +0000

The modern web functions predominately on the use of Application Programming Interfaces (APIs). Many of the APIs return data by passing an array of objects between one another.

This weeks worth of study has been reviewing the LearnJavaScript.online has focused on the management of API data that is in the form of an Array of Objects.

Main Resource - LearnJavaScript.online
Supplementary Resource - MDN JavaScript

What Was Learnt

This weeks worth of learning built on the array functions in the previous week, but with the added complexity of managing an array of object coupled with optional chaining.

Of interest in this week was working with objects simulated against the Twitter API, for example:

const tweets = [
    {
        id: 1,
        message: "Week 2 - JavaScript and Beyond...",
        user: {
            handle: "jack_wj"
        },
        stats: {
            likes: 1,
            retweets: 1
        }
    },
    {
        id: 2,
        message: "Week 3 - Array of Objects",
        user: {
            handle: "jack_wj"
        },
        stats: {
            likes: 1,
            retweets: 1
        }
    }
];

const socialScore = tweets.reduce((total, tweet) => {
    return total + tweet.stats.likes + tweet.stats.retweets;
}, 0);
console.log(socialScore); // 4

const messages = tweets.map(tweet => tweet.message); // [ 'Week 2 - JavaScript and Beyond...', 'Week 3 - Array of Objects' ]
console.log(messages);

One way to improve the visualisation of the objects that are being managed within the array is to change the "current" variable name that is typical used within the reduce function, but instead to refer to it as its singular variable name, in this instance "tweet".

So far this week has begun to introduce me to how APIs manage and send data, which will help build into frameworks such as Express and React.

Resource Review

This week has hasn't had as much progress as previous week, however, the material has begun to gently introduce how APIs manage data in a succinct way that has built off previous weeks.

It has also begun to introduce more intermediate content, such as try...catch, optional chaining, and nullish coalescing.

The LearnJavaScript.online resource has definitely increased in complexity but has managed to maintain its stability in ease of use and structured approach to learning.

Retrospective

I believe with the increase in complexity, it might be worth beginning to look at React or Express to help tie knowledge that is being learnt from LearnJavaScript.online to other content to further compound the lessons that are being learnt. However, this will need to be thought out before committing to it.

Sign Off

Until next week!

~ Jack/eXit

Week 2 - JavaScript and Beyond...

Jack 'eXit' Whitter-Jones — Mon, 09 May 2022 13:33:25 +0000

Understanding how to structure a webpage is one thing, but the most critical aspect of modern day computing and web development is being dynamic and able to manage a wide selection of data.

This weeks post explains the initial week of JavaScript study.

Main Resource - LearnJavaScript.online
Supplementary Resource - MDN JavaScript

What Was Learnt

The early sections of LearnJavaScript.online reviews the basic entry syntax of JavaScript. This provided a suitable recap of the material. However, a key aspect of the weeks learning were the map, reduce, and filter functions for managing content in arrays.

Map

The Map function provides a great way of manipulating the content within an array through a callback function. For example, multiplying each element of an array by 2.

const numbers = [1,2,3];
const multipliedNumbers = numbers.map(number => number * 2); // returns 2, 4, 6

Filter

The Filter function allows the developer to provide logic against the content within an array. For example, finding numbers that are greater than 2:

const numbers = [1,2,3];
const multipliedNumbers = numbers.map(number => number * 2); // returns 2, 4, 6
const filteredNumbers = multipliedNumbers.map(number => number > 2); // returns 4 and 6

Reduce

The Reduce function combines all the arrays contents into a single value based on a set of logic outlined in a callback function. In this case, the reduce function will take the 4 and 6 and multiply them together, resulting in the value 24.

A key note with the reduce function is the number 1 that comes after the callback function. This is to set the total value to the value of 1 and allows 1 * 4 to be legitimate.

const numbers = [1,2,3];
const multipliedNumbers = numbers.map(number => number * 2); // returns 2, 4, 6
const filteredNumbers = multipliedNumbers.map(number => number > 2); // returns 4 and 6
const reducedNumbers = filteredNumbers.reduce((total, current) => total * current, 1); // returns 24 - 1 * 4 * 6;

So far, I am just starting the JavaScript journey, and the content on LearnJavaScript.online is great extremely well outlined, and it is supported with the flashcards and note taking features, which I have noticed a much higher level of retention on key concepts.

Resource Review

Reflecting on last weeks study, FreeCodeCamps provided a snippet-based approach that distilled concept in manageable chunks. However, on review, this does not provide me as learner sufficient depth to critically deploy the technique in question.

Therefore, this week I started using the LearnJavaScript.online course. A structured approach to learning JavaScript through a guided means, that has more in-depth discussion of a particular topic. In addition, supplementary resources are linked to each section providing further reading material.

With the first seven parts of LearnJavaScript.online being free, it provided a good insight into the approach that was taken. It also provides a sufficient approach for learning basic programming to learning JavaScript.

In addition, there is an extensive amount of topics (78 to be exact), which is accessible for five years and provides constant updates for a small one off payment and is supported with a built in flashcard system to help support spaced repetition.

Retrospective

Use the flashcard functionality within the LearnJavaScript.online website before signing off for the day to recap key concepts.

Sign Off

Until the next post!

~ Jack/eXit

Week 1 - Structure and Design

Jack 'eXit' Whitter-Jones — Mon, 02 May 2022 14:38:07 +0000

Structure and design is crucial for anything from console applications and websites. To achieve this, HTML5 and CSS3 are the weapons of choice and being the entry point for most new starters into web development.

This post explains key takeaways that I have learnt over the last week, as well as, a review of the resource of choice, and a retrospective that can be applied going into the next week of learning.

Main Resource: Responsive Web Design Certification
Supplementary Resource: Mozilla MDN - HTML Basic

What Was Learnt

Structure, structure, structure and more structure. HTML is the language of structure, one of the key improvements that I can see from the HTML of the past are more structure tags, such as:

<main></main>
<section></section>
<header></header>
<footer></footer>

With the inclusion of these tags, the construction of a HTML document has much greater levels of granularity. Compared to the classic way of using <div> tags to do the same thing. This simple design choice makes reviewing HTML document structure much easier.

The major takeaway that took a little bit to get into is the difference between the <body> and <main> tags in the Document Object Hierarchy (DOM). The following is an example of a HTML5 document with the new tags:

<!DOCTYPE HTML>
<html>
    <head>
    </head>
    <body>
        <header>
        </header>
        <main>
        </main>
        <footer>
        </footer>
    </body>
</html>

A simple explanation of the difference is, body is for everything in the DOM, while, main is for unique content to that page.

CSS3 has some interesting additions that I have never used. The psuedo-class and the increase in attaching design to almost anything within the DOM object through the regex selectors.

While this has been a brief re-introduction to HTML and CSS, I feel as if these skills will improve over time in conjunction to learning JavaScript.

Resource Review

FreeCodeCamp is a great area to begin with any campaign to learn programming. The bite-sized snippets of explanation and hands on experience provides a suitable initial entry for any level of learner and the exercises provide a suitable incline in difficulty.

However, for me, the snippet structure approach only goes so far. The need for a single flowing document is useful to ensure that my concentration is maximised to grasp the full structure of the topic.

To support the FreeCodeCamps resource, the Mozilla MDN resource - HTML Basic provided a great way of getting concise discussion of HTML5 material to link with the snippet approach outlined by FreeCodeCamps.

Retrospective

Supplement the main resource with a secondary (lighter) resources

Sign Off

The next week will be looking at the main topic of the journey, JavaScript. By having a grasp on HTML5 and CSS3, this knowledge will be extremely helpful when using JavaScript to its fullest.

See you in the following week!

~ Jack/eXit

Week 0 - Competent Scripter to Proficient Programmer

Jack 'eXit' Whitter-Jones — Tue, 19 Apr 2022 17:57:53 +0000

To start something new is always exciting but also some what daunting. As a PhD graduate who has some time to think about my own skillset, I have come to understand that I lack in my technical capabilities of Computer Programming.

While I may be able to do generic scripting and have some capacity at free-thinking while solving minor problems that is typically supported by framework, I have never thought of myself as a proficient programmer, competent maybe, but never proficient.

For me this idea of being a proficient programmer is not something I would like to improve from just a professional capacity, it also plays into my personal passion for which I journeyed into computing in the first place.

My background focuses predominately within the field of Information Security, an area in which, benefits from understanding how to script, but does not require you to be a software engineer. With exposure to Web Development from both a personal and professional capacity, much of the experience of Web Development is now either outdated or knowledge has been typically been masked behind a framework.

The Approach

My aim is to improve my programming proficiency through the medium of Web Development. A field that is accessible, far reaching, resource heavy, and has a very large community spanning many technologies. To scope my learning, I am primarily focusing on HTML, CSS, and JavaScript, with React and Express as my secondary focus. The idea of placing the frameworks as my secondary focus is that I want to develop my understanding around why a framework would be used in a particular instance as to maximise my understanding of the framework further.

To tailor the focus of my learning this blog series aims to document my journey to go from competent scripter to proficient programmer, as well as, to try and answer the following set of questions to help anyone who is in a similar scenario:

What resources should I use?
What language should I learn?
What is the best development stack?
How do I escape tutorial hell?

Target for Success

To be able to determine my journey, the following outputs are what I aim to achieve at the end of the journey:

Contribute to a JavaScript open-source project (at minimum once)
Create a portfolio of five unguided projects
Understand a core front-end and back-end framework
Document my journey

Tenants of the Journey

To guide the learning there are a set of soft rules that I want to apply:

Summarise the learning conducted in that session
Analyse and review material before committing to studying it
Maintaining focus on a single guided resource at any given time
When finishing a guided resource, create and develop an unguided project that has a specification attached before starting another guided resource

Time Frames

Major time commitments should never be taken lightly, instead of doing a daily post as they have never worked for me in the past. A weekly posted instead will be done that is typically posted at the end of the weekend. I hope to maintain the series over a span of 52 week time frame, with a week long break done every so often. However, my progress will be tracked every three months to make sure that I am on track.

Start - 25/04/2022
End - 24/05/2022
Breaks - 28days

Sign Off

Week 1 will be commencing 25/04/2022, this provides me a fresh start to the week and allows some upfront research to tailor my study plan and scouting of resources before beginning.

I look forward to the journey and I hope it is as interesting for you as it is for me.

See you in week 1!

~ Jack/eXit