#creeperhost

Creeperhost.net gives you maximum server customization options for your gaming experience on several different gaming platforms. Their VPS (virtual private servers) have dedicated resources and handled with great care by top quality staff members 24/7 customer service.

My personal experience with Creeperhost.net has been nothing but positive. Project Zearth has been running smoothly for over 2 years now on their VPS, and it’s all thanks to their dedicated servers and setup management.

Their customer service has always been quick to respond when it really mattered, their staff are great problem solvers and just easy to talk to on a regular basis when asked questions.

Their interface is really easy to use and I feel very safe using their services. I couldn’t recommend Creeperhost.net more to anyone who wants to have a serious hosting site and enjoy their gaming experience to the fullest. Without Creeperhost.net Project Zearth v.14 would honestly never have happened.

For more information, visit Creeperhost.net. If you have any questions you have their contact information on the bottom of the page.

Use our coupon to get 10% off your first monthly purchase!

Looking for dedicated server time and well known customer service? Here is your 10% off code from Project Zearth. Visit Creeperhost.net

I don't even know where to start on the connection of actions or whatever to ports, so I'm going to start with just those facts I do know:

The output port must be a signal of some kind. Probably API Requests or whatever I define it as. It doesn't matter what it is, just that it's a signal of it. The type can be defined elsewhere.

Signals can't be created from nothing, and must always have a source, whether it's user input, a ticker, or whatever. Something environmental can be made into a signal, but it has to be something and not nothing.

Signals can be manipulated with various functions such as merge to combine multiple signals into one which has all their events, map to transform values from one signal into values in a new signal, filter to selectively accept or reject certain values from a signal for inclusion in a new signal, and so on.

I need to trigger API requests in reaction to various things:

The Console Log needs to refresh periodically, but not too often. The point being it needs to do this without user interaction. (The exact timing may be set up in JS at first until I have a better grasp of signal manipulation.)

Later on, Console commands need to be sent when the user hits enter on the command line, triggers a macro, or some other thing which trigger console commands.

It sounds like ultimately, my signal source is going to be a signal merged from a couple places:

Certain user actions (Console commands, server restart, etc.)

A Timer for various automatic periodic things. (Console log, server stats...)

As far as how to event start researching this, User Actions seems to be a pretty good place. I use StartApp because it simplifies starting the app, but I currently have no idea what goes on under the hood. I know that user actions are sent to addresses, but I'm not sure how that becomes a signal of actions.

Addresses, it turns out, are usually part of another structure called a Mailbox, which as it happens is a record with two parts: An address and a signal. Ah ha.

Another thing that helped was peering through the code of Evan's Elm implementation of TodoMVC, as he did not use StartApp here. Down at the bottom of Todo.elm, we see this: actions : Signal.Mailbox Action followed by a definition actions = Signal.mailbox NoOp and lo, a Mailbox is created. (As mentioned in the Docs, this also creates a Signal, which is itself impure, thus bolstering my statement of "pure, mostly". This also shows one of my 'facts' was incorrect, and that signals can be created willy nilly.) We also see the definition of main with type Signal Html, and model with type Signal Model. What's in these?

With main, we have main = Signal.map (view actions.address) model. Signal.map has the type Signal.map : (a -> result) -> Signal a -> Signal result, so we know that (view actions.address) is a function that takes a single Model value and returns a single Html value. view is of course Address Action -> Model -> Html but Address Action is already supplied with actions.address, so we're left with just Model -> Html, which looks correct. That leaves model on the end, there, which has the type Signal Model.

I see here that model has the definition model = Signal.foldp update initialModel actions.signal, and finally I see how actions ultimately result in new models. New messages are sent to actions.address, which thus result in those new actions appearing in actions.signal, which itself can be manipulated with the various Signal functions of map, foldp, filter, or whatever.

But wait, how do I use this knowledge with StartApp? StartApp doesn't appear to expose anything to do with a signal of actions. Indeed, it doesn't, as checking StartApp's source code it's plainly seen that actions : Signal.Mailbox Action only shows up in the let part of a let in block. That's no good. So there must be another way to do this without interacting with the Mailbox Action thing. I'll need to look around for an app that does pull information from a server on some user action and see what they do, presuming of course they're doing it correctly, whatever correctly is.

Just as an aside, while I don't know if it will actually make a difference here, Server APIs such as CreeperHost's are usually exposed as Services in JS frameworks, which live outside of the MVC portion.

Note: This is an adventure log showing my experiences learning a new programming paradigm mostly by stumbling about and asking too few questions. Don't take anything here as advice, except when it's a link to someone smarter than I on the topic!

For awhile, I’d wanted to write a small CreeperHost control panel because CreeperHost offers an API to access things such as the current Minecraft console log, restarting the server, seeing usage, etc. I just don’t want to keep logging into their control panel because I’m lazy and hitting the password-fill-in buttons are sooooooo much work. Another big thing is that I'd like to be able to save macros so I can type things like /superbuff ThatGuy in case they run afoul of network malarkey, as happens sometimes when playing on a remote server.

Since, however, I’m learning a new language and new libraries, I need to start small. I can’t just blat things out like I could with a Backbone based thing, so I’m starting with just the console log, and a static one at that. Learning ports will come later.

I also want to practice componentization, so I’m going to split all items into their own modules, but that means that signal routing becomes more interesting since I now have to deal with per-line forwarding.

Most of the Console module was pretty easy. Its model has only one property, the current log, and the view is just a div with the CSS set to whitespace:pre. Eventually that'll get moved out to separate CSS, as is suggested by the Elm App Architecture guide.

However, I got stuck on the Actions. What Actions does the Console have? I don’t know. I put in an action about updating the console’s log, but that didn’t seem to actually fit. It can’t be used outside of the Console module.

I later was lying in bed and, as so often happens, I had an epiphany. I realized that the Actions are for the most part used to express user actions. The Console is entirely passive, at least for now, just, blatting out the log. It itself doesn’t react to user actions, and therefore it has no actions to express, or it could be said it only has a NoOp.

However, this comes to the next problem: How do I translate between the app model and the console model? The console itself will have a separate model definition so I can change later how the console expresses the log, mostly by breaking up lines, formatting them, parsing them for extra info and so on.

Obviously, there needs to be a translation at some point, but where should it be, and what sort of interface should it present?

On top of that, some day I'd like to be able to extract information from the log lines, which means that they'll need some extra log line functions at some point. That means that there will need to be a separate LogLine module, so that's that much solved at least. This also resolves how to pass the log text to the Console: It gets presented with a List LogLine.Model, and in fact just stores them as that in its own model. It may even be worth creating a LogLineList (or at least LogLine.List) type so as to explicitly state that the blob of logs is its own thing, with its own functions. Not going quite that far yet, though.

In the end, I have 3 modules: CreeperPanel, which will be the top level app module, Console, which currently just shows the log lines handed to it, and LogLine. I also stubbed in a couple of lines in CreeperPanel's init function just to make sure things are rendering correctly. On top of that, I didn't have any real errors aside from some type typos born of hasty typing. Since I'm currently not doing anything particularly esoteric, the issues were obvious once I saw them.

There's currently some additional wiring so that proper address forwarding can be set up, some of which may come to nothing, but the intent is that it should be then trivial to add actions later if things change.

Minecraft and other gaming Hosting on low contention Linux Virtual Private Servers

I have been using this company for around half a year so far and i have not had a problem once, Anytime the servers had troubles and I've opened a support ticket they have replied within hours, the servers are pretty damn cheap compared to other companies too.

Nope. Still not okay.

Oh, and they only want three pages of design with no backend? Nope, STILL not okay. That's still three pages of design one person will be paid for and other people won't.