There are instructions all over the place for this sort of thing, so I’m just putting this here for my own reference. I may update it or write new posts as things change significantly.

These instructions are all assuming a headless remote Linux machine will be running the server, so the instructions are based on that.

Step 0

Get the linux server running, set up ssh access, install java, etc.

Step 1 – Install Screen

It’s easiest to run the server on a Screen Window, so go get screen.

Ubuntu/Debian setup:

 sudo apt-get update
 sudo apt-get install screen

Gentoo:

 sudo emerge --sync
 sudo emerge screen

Step 2 – Get the server software

Modpack:

If you’re using a modpack that provides server software, go get that.

Example:

Feed the beast – List of server packs – http://www.feed-the-beast.com/servers/downloads
Monster:

wget http://www.creeperrepo.net/direct/FTB2/f4039de83bfeba547e48047317c4c82e/modpacks%5EMonster%5E1_1_1%5EMonsterServer.zip

unzip the modded server into a directory of your choosing

mkdir ftbMonster
mv *MonsterServer.zip ftbMonster
cd ftbMonster
unzip *.zip

Vanilla (or custom modding):

Go to minecraft.net to get the server software, get the jar: https://minecraft.net/download

Currently:

 wget https://s3.amazonaws.com/Minecraft.Download/versions/1.7.10/minecraft_server.1.7.10.jar

copy the server into a directory of your choosing (to keep things clean):

mkdir minecraft
mv minecraft_server.*.jar minecraft
cd minecraft

Step 3 – Set up the shell script

Modpack:

Odds are there’s already a shells script ready to use, but it might need modifications. For FTB it’s called ServerStart.sh
You can edit this file, but keep reading the vanilla instructions to understand what to modify.

Vanilla:

Create a new file called ServerStart.sh with contents (note: If you’re using a modpack, don’t change anything yet):

java -Xms512m -Xmx1024m -XX:PermSize=256m -jar minecraft_server_1.7.10.jar nogui

What this does:

java = runs java
-Xms512m = tells java the server will use at least 512MB of RAM.
-Xmx1024m = tells java the server can only use up to 1024MB of RAM.
-XX:PermSize=256m = tells java that it should allocate 256MB of space for classes and such. 
This is in addition to the Xmx setting
minecraft_server_1.7.10.jar = the name of the server application
nogui = tells minecraft we don't want to use the GUI

So here’s what to edit:

-Xmx1024m = Set this as high as you're comfortable. Leave some memory for other processes.
-Xms512m = Scale this up some if you've scaled up the maximum.

Leave the permsize unless you’re running significantly more mods, 256Mb should be enough. I haven’t run into any issues with this for the Monster pack from FTB.

Step 4 – Set up ops and server properties

ops.txt should have 1 line per operator. Use the player’s handle.

kadono
Notch

Then set up the server.properties file. This is more complicated than I plan on getting into here, and there’s a good reference here: http://minecraft.gamepedia.com/Server.properties

One note though, if you’re using a white list, be sure to add the users you want to allo in white-list.txt. Ops are automatically allowed, so they don’t need to be in the whitelist.

Step 5.0 – Using Screen

OK, now a short screen cheat-sheet.

First, run screen

>screen

You’re now in a screen window. These windows will keep running even after you detach from them and log off ssh.

Screen uses “Ctrl+a” for its shortcuts. There are a number of shortcuts, so I’m not going to list them all here, just the ones that’ll be needed most frequently.

“Ctrl+a”, “?” – a list of shortcuts (for what’s not listed here)
“Ctrl+a”, “c” – create a new “window”
“Ctrl+a”, “n” – go to next window
“Ctrl+a”, “d” – detach from screen. This will send you back to the shell but keep the screen and all it’s windows running.
“exit” – closes that screen window, if it’s the last window, closes the screen

When you’re detached, to reattach, type

>screen -r

and if there’s one screen it will reattach. If there is more than one, it will ask:

There are several suitable screens on:
 17021.pts-0.machineName (Detached)
 17725.pts-0.machineName (Detached)

To reconnect to one, use:

>screen -r 17021.pts-0.machineName

Step 5.1 – Running the server on a screen

launch screen and navigate to your ServerStart.sh file (in the same directory as your server).

run:

sh ServerStart.sh

and it should work. You should see some stuff being written to StdOut. Try connecting to your server from the local network. If it all looks good, you can detach from the screen and disconnect from ssh. If there are issues, spend some time on Google figuring it out.

Step 6 – Port Forwarding

Forward 25565 to the server (by default)

Step 7 – Do everything else

Choose the mods to use, set up everything, and so on. There are other things you can do like have default resourcepacks and you’ll have to distribute the mods to whomever wants to play on your server. This guide is just for the initial basic setup, so all of the fancier stuff can be handled by Google. If I make some other guides, I may link them here.

Again, this guide was for myself as a quick reference, if it was useful to you, I’m glad. If it’s not, then head over to http://minecraft.gamepedia.com/Tutorials/Setting_up_a_server

Lesson 2: Keep on moving, text

This article is part of a series. Part 1 and table of contents.

Here’s a surprising fact, for some of you this text will scroll.

We have to assume that the marquee’s days are numbered, though. The marquee tag started its life in Internet Explorer, back in the bad old days. If you search for ‘marquee tag’ on Google, the results are in a marquee tag. But the Wikipedia page describing it basically just spends the entire time saying “Don’t”

If you remember the GeoCities days, almost every page (every page that was worth reading, anyways) had at least one element where someone did <blink><marquee>This text is important!</marquee></blink> so that it would stand out regardless of which browser you use.

By the end of this lesson, we’ll make this monstrosity a reality. The blinking marquee.

Alright, if you remember last time, when we made blinking text, we just used setInterval to keep updating the canvas. We’re going to do something like that again.

First thing’s first, let’s use the same HTML as last time (more or less):

<html>
<head>
</head>
<body>
<button onclick="startScrolling()">Start Scrolling!</button>
<canvas id="canvas1" width="500px" height="100px" />
</body>
</html>

I made the height smaller, since the 500px height was probably too much. You with me so far? Easy, right? Good. Let’s move on to making a simple class called Scroller that will handle the canvas and our scrolling text. For now, let’s just pass in a reference to the canvas, the text we want to scroll, and have our drawtext method. We’re going to make that startScrolling() function as well. Here’s the code:

function startScrolling()
{
    var c = document.getElementById("canvas1");
    var scroller = new Scroller(c, "Welcome to my homepage! Sign my guestbook!");
    scroller.drawText();
}

function Scroller(canvas, scrollingText)
{
    this.canvas = canvas;
    this.text = scrollingText;
    this.yloc = 10;
    this.xloc = 0;
    this.drawText = function()
    {
        var context = this.canvas.getContext("2d");
        context.fillText(this.text, this.xloc, this.yloc);
    };
}

OK, let’s go over the code, though if you did part one of this series, you everything will be familiar. The startScrolling() function is what we’re calling when we press the button. From there we create an instance of our Scroller and manually call the drawText() method.

The Scroller takes a reference to the canvas and some text, saves it interally, and has default x and y values. The y value is set to 10 so we can see the text, since unlike regular HTML the text doesn’t draw from a box starting on the upper left, it starts drawing from the text’s baseline. So we have to adjust for that. Here’s a fiddle with the working code so far: http://jsfiddle.net/kadono/QLSGJ/

Sweet, we drew some text, let’s keep going and make it move. The canvas has a few different ways we can do this, but we’re going to use the window’s requestAnimFrame method. Actually, before we move on, let’s talk about requestAnimFrame a bit.

requestAnimationFrame

I’m going to pass on the sarcastic tone for this part of the guide. When we made our dumb blinking text, it was kind of funny to make it use too many resources. However, we were only calling the method with setInterval every 500ms, and it took almost no time to run, so it wasn’t really that big of a deal. If we want to have nice, buttery animation we’re going to want to run way more often than twice per second, though. So we should think a little more about the resources we’re using.

requestAnimationFrame is a relatively new method added to the DOM. Until very recently, it wasn’t available on any mobile platforms, though now it’s on the lastest versions of the iOS and Android default browsers. Still, before we go any further, if you’re going to use the requestAnimationFrame method (which you should), then you use use Paul Irish’s gist, located here: https://gist.github.com/paulirish/1579671 Just throw that code in at the top of your Javascript, and now you have requestAnimationFrame, even on older browsers. There are other shims that add the method or extend on it, but we’re not going to cover those here.

Ok, so why do we want to use requestAnimationFrame? Well, we could just use setInterval(someFunction, 1000/60) to get 60fps and it’ll look good, right? That works, but it’s like trying to pull a tooth with a sledgehammer. Too much tool, too much collateral damage. We need to use some finesse.

When we use requestAnimationFrame, a few things happen.

1. The code will run immediately before the page redraws, not accidentally during the redraw or in some other non-ideal situation.
2. The code won’t run if the tab isn’t visible, saving battery on laptops and things. It’s not like we need it to run then anyways.
3. We get something much closer to an update/draw loop we can use.

Overkill for our project? Probably, but it’s good to use good coding practices, even if we’re doing awful things in the process. Let’s talk about this method a little more generally before we move into our actual implementation.

The recommended usage of requestAnimationFrame moves our animation code from this:

setInterval(someFunction, 1000/60);

To this:

(function mainloop()
{
    requestAnimationFrame(mainloop);
    someFunction();
})()

So you can see, that once you call mainloop() once, it will continue to run recursively forever. So, requestAnimFrame takes a callback function, then calls that function at the appropriate time. Using this type of layout, we have an infinite loop, except it only continues when requestAnimationFrame decides it’s time to call the callback function. We get another benefit as well. requestAnimFunction actually returns a reference we can use to cancel the animation with another method: cancelAnimationFrame

So we can have the following:

var animId;

function mainloop()
{
    animId = requestAnimationFrame(mainloop);
    someFunction();
};
function stopAnimating()
{
    cancelAnimationFrame(animId);
};

So you can see what’s going on here. When we call cancelAnimationFrame(animId) it tells the system not to do the callback we previously asked it to do. That breaks the recursion in our function and stops the animation.

Back to the Marquee

Now that we have some idea how we can do smooth animation without killing the performance, let’s start working on this, shall we?

Last time we had to do some trickery to change the relative value of “this” when a function was called as the setInterval callback. We’re going to have to do the same thing with requestAnimationFrame. Since I like to add one thing at a time, we can start by getting the requestAnimationFrame working. We’re going to add our new callback method called doAnimation, which for now will just update a frame counter and draw the text. We won’t be keeping the frame counter around for too long, it’s just a way to confirm our animation is working. Here’s the code:

function startScrolling()
{
    var c = document.getElementById("canvas1");
    var scroller = new Scroller(c, "Welcome to my homepage! Sign my guestbook! Frame count:");
    scroller.doAnimation();
}

function Scroller(canvas, scrollingText)
{
    this.canvas = canvas;
    this.text = scrollingText;
    this.yloc = 10;
    this.xloc = 0;
    var self = this;
    this.animId;
    this.counter = 0;
    this.doAnimation = function()
    {
        this.animId = requestAnimationFrame(function() { self.doAnimation(); });
        this.counter++;
        this.drawText();
    }
    this.drawText = function()
    {
        var context = this.canvas.getContext("2d");
        context.clearRect(0, 0, this.canvas.width, this.canvas.height);
        context.fillText(this.text + this.counter, this.xloc, this.yloc);
    };
}

You can see we’re keeping around a reference so we can stop the animation later. Pretty simple change, huh? You can see the code working here: http://jsfiddle.net/kadono/Lh8jj/ and if you start the frame counter and flip over to another tab and come back, you’ll see that it hasn’t been increasing while it was invisible. Nice, huh? And we didn’t even have to do anything except use requestAnimationFrame to get that nice little piece of functionality.

Also, we added a clearRect call to clear out the canvas before we draw the text, otherwise we’ll just be stacking the text on top of itself over and over forever, and that’s no good. We’re going to need to do that when we animate the text anyways, so we might as well get it in now.

So what should we be doing to move the text? Let’s consider how a marquee tag works:

1. Text should move from right to left
2. The entire text should move out of sight before it starts scrolling in from the right again
3. Since there isn’t a standard, we can eyeball the rate it moves.
4. There are a number of behaviors and modifiers we can emulate if we want

Out of extreme laziness, we’re going to go with the default scroll rate being 1 pixel per frame, which ends up being 60 pixels per second if we’re running at 60fps. Regardless of the rate, it’ll look smooth since it only moves one pixel at a time. So we can do that just by decrementing the xloc every frame. But what about when the text has move entirely off the frame? That’s simple, we can measure the text using the canvas method measureText and move the text off the right side of the canvas after the -xloc is bigger than the measureText length.

Just look at the code, it’ll make sense:

function startScrolling()
{
    var c = document.getElementById("canvas1");
    var scroller = new Scroller(c, "Welcome to my homepage! Sign my guestbook!");
    scroller.doAnimation();
}

function Scroller(canvas, scrollingText)
{
    this.canvas = canvas;
    this.text = scrollingText;
    this.textWidth = 0;
    this.yloc = 10;
    this.xloc = this.canvas.width;
    this.font = "12px Arial";
    var self = this;
    this.animId;
    this.doAnimation = function()
    {
        this.animId = requestAnimationFrame(function() { self.doAnimation(); });
        if(this.textWidth == 0)
        {
            var context = this.canvas.getContext("2d");
            context.font = this.font;
            this.textWidth = context.measureText(this.text).width;
        }
        if(this.textWidth + this.xloc < 0)
        {
            this.xloc = this.canvas.width;
        }
        else
        {
            this.xloc--;
        }
        this.drawText();
    }
    this.drawText = function()
    {
        var context = this.canvas.getContext("2d");
        context.clearRect(0, 0, this.canvas.width, this.canvas.height);
        context.font = this.font;
        context.fillText(this.text, this.xloc, this.yloc);
    };
}

OK, so major changes:

• We’re setting a font, this is to make sure that measureText() behaves predictably
• We got rid of the frame counter
• We’re starting the text off the right side of the canvas so it will scroll in
• We’re measuring the text, but only if it hasn’t been measured before
• If the text is entirely off the canvas, we reset it to the right side, otherwise we move it left.

Sweet, we have a basic, working marquee. Here’s the fiddle if you want to play with it: http://jsfiddle.net/kadono/N692p/

Now, we could add a bunch of options on here, like adding support for different speeds, colors and directions. So, let’s just do it. The only canvas-type code we’ll be adding here is we’re going to use the fillStyle. All we need to do is set the context’s fillStyle property to a hex value string to set the color. The rest of the code is just simple switches and math, so I won’t go into detail on that. I’ll just show you the code:

function startScrolling()
{
    var c = document.getElementById("canvas1");
    var scroller = new Scroller(c, "Welcome to my homepage! Sign my guestbook!", 1, "down", "#CC0000");
    scroller.doAnimation();
}

function Scroller(canvas, scrollingText, rate, direction, textColor)
{
    this.canvas = canvas;
    this.text = scrollingText;
    this.textWidth = 0;
    this.textHeight = 12;
    this.yloc = 10;
    this.xloc = this.canvas.width;
    this.rate = rate;
    this.direction = direction;
    this.textColor = textColor;
    this.font = "12px Arial";
    var self = this;
    this.animId;
    if(this.direction == "up")
    {
        this.xloc = 0;
        this.yloc = this.canvas.height;
    }
    else if(this.direction == "down")
    {
        this.xloc = 0;
        this.yloc = 0;
    }
    this.doAnimation = function()
    {
        this.animId = requestAnimationFrame(function() { self.doAnimation(); });
        if(this.textWidth == 0)
        {
            var context = this.canvas.getContext("2d");
            context.font = this.font;
            this.textWidth = context.measureText(this.text).width;
        }
        if(this.direction == "left")
        {
             if(this.textWidth + this.xloc < 0)
             {
                 this.xloc = this.canvas.width;
             }
             else
             {
                 this.xloc -= this.rate;
             }
         }
         else if(this.direction == "right")
         {
            if(this.xloc > this.canvas.width)
            {
                this.xloc = - this.textWidth;
            }
            else
            {
                this.xloc += this.rate;
            }
        }
        else if(this.direction == "up")
        {
             if(this.yloc < 0)
             {
                 this.yloc = this.canvas.height + this.textHeight;
             }
             else
             {
                 this.yloc -= this.rate;
             }
        }
        else if(this.direction == "down")
        {
             if(this.yloc > this.canvas.height + this.textHeight)
             {
                this.yloc = 0;
             }   
             else
             {
                this.yloc += this.rate;
             }
        }
        this.drawText();
    }
    this.drawText = function()
    {
        var context = this.canvas.getContext("2d");
        context.clearRect(0, 0, this.canvas.width, this.canvas.height);
        context.font = this.font;
        context.fillStyle = this.textColor;
        context.fillText(this.text, this.xloc, this.yloc);
    };
}

And here’s the fiddle: http://jsfiddle.net/kadono/zpnru/ This is probably not the most efficient way of making this method, but hey, we’re already doing some pretty nasty anti-design patterns, so what’s some not-completely-efficient code, eh?

This is probably enough, right? Yeah, this is definitely enough. We have a working marquee element that has EVEN WORSE USABILITY than the actual marquee tag. We can do other things like add a “stop” function and put that in the mouseover, and other things, but I’ll leave that exercise to the reader.

The monstrosity

I promised this, so let’s get that blinking marquee text going. We’ll put a blinkrate into the previous method, and count frames to keep track of if we should be showing the text or not.

I’m really not proud of this, but in an odd way I am proud of this. The realization of that horrible nested tag from the 90’s:

function startScrolling()
{
    var c = document.getElementById("canvas1");
    var scroller = new Scroller(c, "Welcome to my homepage! Sign my guestbook!", 1, "left", "#CC0000", 30);
    scroller.doAnimation();
}

function Scroller(canvas, scrollingText, rate, direction, textColor, blinkRate)
{
    this.canvas = canvas;
    this.text = scrollingText;
    this.textWidth = 0;
    this.textHeight = 12;
    this.yloc = 10;
    this.xloc = this.canvas.width;
    this.rate = rate;
    this.direction = direction;
    this.textColor = textColor;
    this.blinkRate = blinkRate;
    this.showText = true;
    this.frameCount = 0;
    this.font = "12px Arial";
    var self = this;
    this.animId;
    if(this.direction == "up")
    {
        this.xloc = 0;
        this.yloc = this.canvas.height;
    }
    else if(this.direction == "down")
    {
        this.xloc = 0;
        this.yloc = 0;
    }
    this.doAnimation = function()
    {
        this.animId = requestAnimationFrame(function() { self.doAnimation(); });
        if(this.textWidth == 0)
        {
            var context = this.canvas.getContext("2d");
            context.font = this.font;
            this.textWidth = context.measureText(this.text).width;
        }
        if(this.blinkRate > 0)
        {
            this.frameCount++;
            if(this.frameCount > this.blinkRate)
            {
                this.showText = !this.showText;
                this.frameCount = 0;
            }
        }
        if(this.direction == "left")
        {
             if(this.textWidth + this.xloc < 0)
             {
                 this.xloc = this.canvas.width;
             }
             else
             {
                 this.xloc -= this.rate;
             }
         }
         else if(this.direction == "right")
         {
            if(this.xloc > this.canvas.width)
            {
                this.xloc = - this.textWidth;
            }
            else
            {
                this.xloc += this.rate;
            }
        }
        else if(this.direction == "up")
        {
             if(this.yloc < 0)
             {
                 this.yloc = this.canvas.height + this.textHeight;
             }
             else
             {
                 this.yloc -= this.rate;
             }
        }
        else if(this.direction == "down")
        {
             if(this.yloc > this.canvas.height + this.textHeight)
             {
                this.yloc = 0;
             }   
             else
             {
                this.yloc += this.rate;
             }
        }
        this.drawText();
    }
    this.drawText = function()
    {
        var context = this.canvas.getContext("2d");
        context.clearRect(0, 0, this.canvas.width, this.canvas.height);
        if(this.showText)
        {
            context.font = this.font;
            context.fillStyle = this.textColor;
            context.fillText(this.text, this.xloc, this.yloc);
        }
    };
}

And the fiddle: http://jsfiddle.net/kadono/4eVKb/

So there we have it, blinking scrolling text.

Future Developments?

Well, if you want, you could implement all of the options the marquee element has/had. You could add the stop() function, allow for more dynamic speeds, allow images in the marquee, and so on. I’m not going to do any of that in this tutorial, but you should be able to do most of those pretty easily from what we’ve done here.

If you wanted to go even farther, you could add diagonal scrolling, gradients instead of colors, or even moving/changing gradients. Amazing, don’t you think!

I hope you’ve learned more about the canvas today, and more about website usability!

This is my monthly attempt at keeping at it. These posts aren’t crafted, they’re brain dumped, so please excuse the poor writing and comma abuse. The original post is here. I’m kind of making it up as I go here, so I apologize if I jump around a little. But basically the plan is to do weekly and monthly reviews. I’ll post occasional weekly updates as well. There’s other monthly review stuff I do, but the goals side of the monthly reviews I’ll post here. 

OK, this month has been odd. And clearly I haven’t been doing as many posts as I should. Oh well, we’ll get to that soon. On to the summaries:

Summary of February

February had some of that second month “blah” to it, but I’m getting reinvigorated as the month comes to a close.

Goal Progress

1. Lose 60 70 pounds

Well, an odd thing happened here. So I got a new scale, and it reported me as 10 pounds heavier. Ok, that’s fine. But my actual written goal was getting under a specific weight. I decided not to change my actual goal, so this relative-looking one had to change. That means the “lose 100 pounds” has become “lose 110 pounds” as well. Alright, that’s fine. I’ve been in that “post induction stall” for a while as well, but I think that I’ve finally gotten past it in the last couple of days, so hopefully I’ll start to see some real progress again in March. Still, February wasn’t as bad as it could have been.

Monthly Progress: 6 pounds
Total Progress: 19 pounds
Ratio: 19/70 ~ 27.14%

Thoughts: It wasn’t as successful as January, but I still made progress. Unless you count the moving goalpost. Hopefully the posts don’t move any farther. Still can possibly hit the bigger goal (110). So, let’s see how March goes.

2. 3. 4. Writing

I did some work on the light novel series, and I wrote a short story (that I’ll be adapting into a novella). I also did some revisions on both. More on this later, I think, but here are some word counts:

Monthly Progress: 6859 words written, Novella plan, LN plans solidifying, 3 revisions done
Total Progress: 6859 words written

Thoughts: I’m actually going to do a while post on the “novella plan” but it’s basically a way to force myself to finish things I can actually publish. I have plans to push hard on writing in March.

5. 50 posts published here

Been hung up on a bigger technical post. Maybe I should pick easier things to write about.

Monthly Progress: 3 posts
Total Progress: 5/50
Ratio: 5/50 ~ 10%

Thoughts: I still didn’t make 1 post / week. I still need to catch up. Once I finish this API documentation I’m hoping to catch up.

6. 8. – Twitter/Twitch Followers

Welp, this might be done. I tried pushing a patreon page to actually get some financial support for this and it failed completely. This has taken a lot of the wind out for me, and I’m not sure I’ll push on this front too hard anymore. Writing might be the better option. We’ll see.

Twitter: No change
Twitch: 100 total followers

7. JLPT Prep

This is hard to update, since there’s no number before December. I’ve been studying using Anki primarily, and I feel like I’ve been making progress there. I have Hiragana on lock (still mix up chi/sa once in a while), getting better at Katakana, and chipping away at Kanji. I’m planning on tearing apart (well, maybe not), scanning, and home translating some manga. Kind of to supplement things. We’ll see.

8. Outside Income

Patreon didn’t work out, but I tried. I’m going to push much MUCH harder into the writing side of things, and hopefully a little money will come out of there. That’s not the main goal, but it would be a nice indicator of success.

Not sure there will be any real progress by the end of next month, but we’ll see.

10. 11. Podcast/Plushies

Nothing done here.

12. – 22. Bonus Goals

(14) I’m pushing to get the publishing company formed soon.
(16) Manuscript number might be changed/adapted due to the Novella Project

No other significant tracking on the other bonus goals.

Final Thoughts and Looking Forward

Not the best month, not the worst month. I have some other things going on that I’m not posting here that are significantly cutting into my time to get goal based stuff done. I’m having a hard time getting everything done at the same time. I’ve been putting one or the other project on the side while I’ve been focusing on others. I spent quite a bit of effort on Twitch, and that seems to have been barking put the wrong tree. That’s OK, but I need to pivot now. Expect a lot more progress on the writing goals.

Direction and Focus this month:

1. Focus on the task at hand. One task at a time.
2. Write, plan, build worlds, blog. Make serious progress.
3. Morning Pages – Keep at it
4. 1 Novella written and ready
5. 1 Issue of LN done

See you next month.

“Weekly” Update here.

Probably only interesting to me, so I can track things better and keep on top of stuff.

Weight: Funny story. Humidity killed the scale, got a new one the next day “gained” 10 lbs. So, I’m operating on the assumption that I actually started 10 lbs heavier. I’d say this is within +/- 2lb of accurate. So, what do I do about my goals? Well, my actual written one is being under a certain weight, and I’m keeping that the same. So now it’s “lose 70 lbs” and “lose 110 lbs” instead of 60/100. Harder, but still possible I’d say. Either way, I don’t want my actual goals to change. Assuming that, I’ve just started to break my stall.

Weekly Progress: 3.6 lbs lost.

Writing & Posts: About 3500 words in the light novel series. Started on a technical blog post but hit a wall. I know what to do with it now, even though I’ll be changing direction on it. This is post #4/50 published.

Twitch: Been streaming pretty regularly, Just hit 100 followers (woo). I haven’t done anything popular yet either, so I’m not unhappy with how it’s going.

Focus this week: Blog posts, writing, brainstorm for podcast / youtube show / etc