Optimism, Dedication, Persistence, and Leadership: The Hosting Industry According to Khalid Cook, Director of HostSailor

Our interview series has featured some of the true titans of the hosting industry. In this installment, we sit down with Khalid Cook, director of HostSailor.  HostSailor has been a regular here on LEB and LET, regularly giving our users great offers on cheap quality hosting.  They’ve been in business since 2014 and along the way, Khalid has learned a lot.  In this interview he discusses the highs and lows of life in hosting, what he’s learned, and HostSailor’s future.

Tell me about your background and your company’s history?

I have been in the hosting industry ever since I was 15 years old, sold shell accounts at the peak time of mIRC and helped a lot of people keep their nicknames and accounts online around the clock, over time I’ve developed my skills and experience that have helped me work with a few hosting companies from scratch. In 2014 HostSailor was born and from there we have been targeting lowend and budget customers who have found our services not only affordable but also offered stability, multi location, free support and several other benefits that come at no extra cost, HostSailor continues to offer Dedicated servers, virtual servers, shared hosting, ssl certificates and domain names.

What would you tell someone looking to start a hosting company today? What advice would you offer?

Building a new hosting company takes a lot of patience, experience and persistence. Starting your hosting company with as little resources as possible would be a better approach for your startup, for example if you are interested in shared hosting or have had experience with cPanel then starting the business with a single cPanel server to test the waters would minimize your losses and help you have a clearer image on your next steps.

Where do you think the future takes the hosting industry?

The hosting industry will continue and stay for as long as the market is in need of hosting services, I believe that with new ingenious ideas and a mix of new technology and classic hosting the industry will continue to flourish.

Tell me about your top two failures in business? What did you learn from them?

  • Onboarding the wrong team members: Extra care has to be taken when onboarding new team players, without the right team you are not able to sail your business to reach the goals you have set.
  • No/poor Credit cards payment verification: Using a merchant service to receive credit card payments on behalf of your customers is an important aspect of earning your revenue online however if you do not run aggressive verifications for the payments you receive online you may end up losing a lot of your revenues, pay chargeback fees and end up losing your hard earnings.

Tell me about your top two successes in business?

  • Investing heavily into buying our own hardware have proven overtime after ROI to help the business earn high profit margins that in return helped the business grow and expand further.
  • Ongoing staff meetings, proper task management software, and having creative team members contribute into the decisions of the company has proven to be more successful than dictating everything on your own as a business owner.

What do you enjoy most about your role? What do you find most difficult?

Reaching specific goals either short term or long term brings me joy, nothing is easy in doing business and everyday brings new challenges and obstacles that I have to find ways to tackle.

Both personally and professionally, what guiding principles ground you?

Optimism, dedication, persistence, creativity, leadership, honesty are one of the principles I hold tight to.

Give us some details on new and exciting things you are working on?

We are trying to establish new locations, provide a new line of premium services, and expand the business to specific regions around the world.

Why should customers trust you and your business?

With 20 years of experience in the hosting industry I know how to value customers, HostSailor has been in business for over 7 years and over the years we have built trust and maintained our reputation online.

Final thoughts and anything you would like to add?

We’ve been investing heavily into the internal structure of the company, offering new services, focusing on customers and their needs, improving our overall customer service, and the upcoming years we’re looking forward to a healthy growth and expansion in the market. I and my team are thanking LowEndTalk for their continues support over the years and the great job they have done for the lowend community, we would also like to thank all our customers either existing, former or potential for choosing us and putting their trust in HostSailor.

 

raindog308

I’m Andrew, techno polymath and long-time LowEndTalk community Moderator. My technical interests include all things Unix, perl, python, shell scripting, and relational database systems. I enjoy writing technical articles here on LowEndBox to help people get more out of their VPSes.

java – Maven project using EclipseLink for persistence runs on IDE, but fails when running from a built jar

I’m working on a maven project using eclipselink 2.7.8 for persistence. When I run it on my IDE (Netbeans 12.0) it works perfectly well, but when I attempt to run it from a built jar it doesn’t.

This is the stack trace when I use the jar

Exception in thread "main" Local Exception Stack:
Exception (EclipseLink-30005) (Eclipse Persistence Services - 2.7.8.v20201217-ecdf3c32c4): org.eclipse.persistence.exceptions.PersistenceUnitLoadingException
Exception Description: An exception was thrown while searching for persistence archives with ClassLoader: jdk.internal.loader.ClassLoaders$AppClassLoader@2cdf8d8a
Internal Exception: javax.persistence.PersistenceException: Exception (EclipseLink-28018) (Eclipse Persistence Services - 2.7.8.v20201217-ecdf3c32c4): org.eclipse.persistence.exceptions.EntityManagerSetupException
Exception Description: Predeployment of PersistenceUnit (MyPersistenceUnit) failed.
Internal Exception: java.lang.NullPointerException
        at org.eclipse.persistence.exceptions.PersistenceUnitLoadingException.exceptionSearchingForPersistenceResources(PersistenceUnitLoadingException.java:129)
        at org.eclipse.persistence.jpa.PersistenceProvider.createEntityManagerFactoryImpl(PersistenceProvider.java:118)
        at org.eclipse.persistence.jpa.PersistenceProvider.createEntityManagerFactory(PersistenceProvider.java:191)
        at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:80)
        ...
Caused by: javax.persistence.PersistenceException: Exception (EclipseLink-28018) (Eclipse Persistence Services - 2.7.8.v20201217-ecdf3c32c4): org.eclipse.persistence.exceptions.EntityManagerSetupException
Exception Description: Predeployment of PersistenceUnit (MyPersistenceUnit) failed.
Internal Exception: java.lang.NullPointerException
        at org.eclipse.persistence.internal.jpa.EntityManagerSetupImpl.createPredeployFailedPersistenceException(EntityManagerSetupImpl.java:2109)
        at org.eclipse.persistence.internal.jpa.EntityManagerSetupImpl.predeploy(EntityManagerSetupImpl.java:2085)
        at org.eclipse.persistence.internal.jpa.deployment.JPAInitializer.callPredeploy(JPAInitializer.java:104)
        at org.eclipse.persistence.jpa.PersistenceProvider.createEntityManagerFactoryImpl(PersistenceProvider.java:107)
        ... 15 more
Caused by: Exception (EclipseLink-28018) (Eclipse Persistence Services - 2.7.8.v20201217-ecdf3c32c4): org.eclipse.persistence.exceptions.EntityManagerSetupException
Exception Description: Predeployment of PersistenceUnit (MyPersistenceUnit) failed.
Internal Exception: java.lang.NullPointerException
        at org.eclipse.persistence.exceptions.EntityManagerSetupException.predeployFailed(EntityManagerSetupException.java:233)
        ... 19 more
Caused by: java.lang.NullPointerException
        at org.eclipse.persistence.internal.jpa.metadata.MetadataProject.hasEntity(MetadataProject.java:1441)
        at org.eclipse.persistence.internal.jpa.metadata.accessors.objects.MetadataAnnotatedElement.isOneToMany(MetadataAnnotatedElement.java:693)
        at org.eclipse.persistence.internal.jpa.metadata.accessors.classes.ClassAccessor.buildAccessor(ClassAccessor.java:609)
        at org.eclipse.persistence.internal.jpa.metadata.accessors.classes.ClassAccessor.addAccessorFields(ClassAccessor.java:438)
        at org.eclipse.persistence.internal.jpa.metadata.accessors.classes.ClassAccessor.addAccessors(ClassAccessor.java:410)
        at org.eclipse.persistence.internal.jpa.metadata.accessors.classes.ClassAccessor.preProcess(ClassAccessor.java:1225)
        at org.eclipse.persistence.internal.jpa.metadata.accessors.classes.EmbeddableAccessor.preProcess(EmbeddableAccessor.java:304)
        at org.eclipse.persistence.internal.jpa.metadata.MetadataProject.processStage1(MetadataProject.java:1851)
        at org.eclipse.persistence.internal.jpa.metadata.MetadataProcessor.processORMMetadata(MetadataProcessor.java:579)
        at org.eclipse.persistence.internal.jpa.deployment.PersistenceUnitProcessor.processORMetadata(PersistenceUnitProcessor.java:629)
        at org.eclipse.persistence.internal.jpa.EntityManagerSetupImpl.predeploy(EntityManagerSetupImpl.java:2006)
        ... 17 more

My persistence.xml:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
      <persistence-unit name="MyPersistenceUnit" transaction-type="RESOURCE_LOCAL">
        <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
        ...
        <exclude-unlisted-classes>false</exclude-unlisted-classes>
        <properties>
            <property name="javax.persistence.jdbc.url" value="jdbc:h2:./bd/MyPersistenceUnit"/>
            <property name="javax.persistence.jdbc.user" value=""/>
            <property name="javax.persistence.jdbc.driver" value="org.h2.Driver"/>
            <property name="javax.persistence.jdbc.password" value=""/>
            <property name="javax.persistence.schema-generation.database.action" value="create"/>
        </properties>
    </persistence-unit>
</persistence>

My pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    
    <modelVersion>4.0.0</modelVersion>
    <groupId>xxxx.xxxxx</groupId>
    <artifactId>Service</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    
    <properties>      
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.eclipse.persistence</groupId>
            <artifactId>eclipselink</artifactId>
            <version>2.7.8</version>
        </dependency>
        
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>1.4.194</version>
        </dependency>

        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.7.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>5.7.0</version>
            <scope>test</scope>
        </dependency>

        <dependency>          
            <groupId>org.fusesource.jansi</groupId>
            <artifactId>jansi</artifactId>
            <version>2.3.2</version>
            <type>jar</type>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
            <type>jar</type>
        </dependency>        
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <executions>
                    <execution>
                        <id>example</id>
                        <configuration>
                            <archive>
                                <manifest>
                                    <mainClass>xxxx.xxxxx.service.demonstration.MainDemo</mainClass>
                                </manifest>
                            </archive>
                            <descriptorRefs>
                                <descriptorRef>jar-with-dependencies</descriptorRef>
                            </descriptorRefs>
                            <appendAssemblyId>false</appendAssemblyId>
                        </configuration>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

        </plugins>
    </build>

</project>

I suspect that it’s something to do with how maven is building the jar, since it works fine on the IDE. I have tried to utilize different eclipselink versions too, but that didn’t seem to help (I started this project using 2.5.2 but updated after I had problems due to incompatibilities with some Java 8 features)

magento2 – How to add persistence to a image field dynamically

your add / edit form should have a data provider attached to it. Your data provider should return an array that should contain a field called the same as your field that holds the path to the image and a few other details

Something like this:

$data['field'] = [
                    0 => [
                        'name' => 'filename goes here',
                        'url' => 'url to image goes here',
                        'size' => 'image size goes here',
                        'type' => 'image mime goes here. try with  "image"'
                    ]
                ];

pathfinder 1e – Persistence Inquisition Relentless Footing duration

The Persistence Inquisition grants the Relentless Footing ability:

Relentless Footing (Ex): As a swift action, you can add 10 feet to your land speed. This increase counts as an enhancement bonus, and it affects your jumping distance as normal for increased speed. You can use this ability a number of times per day equal to 3 + your Wisdom bonus (minimum 1).

The description does not say how long the enhancement lasts. How long does this effect last?

topological data analysis – Persistence barcodes given a sequence of abstract homology groups

For a sequence of nested complexes $K_1subset K_2 subset K_3$, I have calculated the first homology groups at each level,

$$
H_1(K_1)=left<a,bright>cong mathbb{Z}^2\
H_1(K_2)=left<a,b,cright>cong mathbb{Z}^3\
H_1(K_3)=left<a,b,cright>/left<a+b+cright>congleft<a,bright>congmathbb{Z}^2\
$$

where $a$, $b$, and $c$ are 1-simplexes and the homology groups are constructed with integer coefficients from these generating elements.

In this scenario, how do I go about drawing the barcode for $H_1$? I know the rank of $H_1$ should match the number of generating elements, so it should be $2,3,2$ in this case.

For the first two groups ($H_1$ and $H_2$) I could imagine taking one bar for the element $a$ and one bar for $b$, that are both present at all stages. However, the quotient $H_1(K_3)$ is also isomorphic to $left<b,cright>$, so using this strategy can lead to at least two very different barcodes (see image below)?

barcode examples

This represents whether $c$ is used as a generating element in $H_1(K_3)$ or not. The rank (number of bars) is correct for both barcodes. Anyway, it seems I am wrong on how to construct barcodes since I expected a single correct answer. How should one go about this?

python – Finding the ‘ Multiplicative persistence ‘ of a number

I was trying to find the multiplicative persistence of a number(i.e.. How many iterations of creating a new number from multiplying the digits of a given number will end up in a single digit number?). I came up with the following code.

I orginally meant it for giving a certain number for Multiplicative persistence and getting an output of a number that had the specified Multiplicative persistence.

As a prototype i wrote the following

a=10
for i in range(0,30):
    c=a
    count=0
    while c>9:
        b=1
        for digits in str(a):
            b=b*int(digits)
            c=b
            count=count+1
    if count==2:
        print(a)
    a=a+1

And, it worked fine…. It spit out all the numbers from 10 to 24 which was expected(from 25 you dont get to single digit numbers in one step)

But when at line 11 , I put count==3 , the code wouldnt be executed .. i expected it to find 25 fairly quickly… But it didnt , it said the program was still running and that was the end of it. What is wrong here?

I am 15 and extremly new to python (about 6 months) and would appreciate any advice or critiscm.

domain driven design – What is the relationship between Event Store and Persistence Mechanism when designing Aggregate + Event Sourcing?

I’m trying to implement an Event Store, to be used with Aggregate+Event Sourcing (A+ES), and I’ve run into I think a gap in understanding.

I’m reading Implementing Domain Driven Design, using both the Domain Event/Event Store and Appendix A: A+ES sections as a template/guide.

In the book, there are two types used, the Event Store, and an IAppendOnlyStore. The examples are in C#.

The book goes on to say

As illustrated in Figure A.14, the class implementing IEventStore is a project-specific wrapper around the more generic and reusable IAppendOnlyStore. While the IEventStore implementation deals with serialization and strong typing, the IAppendOnlyStore implementations provide low-level access to various storage engines.

Implementing Domain Driven Design (Vaughn, p. 563)

Different IAppendOnlyStore implementations can exist. Some examples the book gives are File-based, MS SQL Server, MySQL, Windows Azure Blob, and MongoDB.

The IAppendOnlyStore contains methods that operate on byte() objects. According to the book, the Event Store is responsible for serializing and deserializing a Domain Event into a byte(). The Event Store then passes the serialized byte() to the IAppendOnlyStore, which then persists the byte() into the persistence store. The IAppendOnlyStore also has methods for retrieving records from the persistence store. Whether appending or retrieving, a unique identifier is used to indicate which records to retrieve, or which event stream to persist to.

Here’s where the gap in my understanding comes in. The example implementation of Relational Persistence in the book uses MySQL. The MySQL IAppendOnlyStore implementation persists the events in a table, that has columns (Id, Name, Version, Data). Id is a unique, persistence local identity for the record, Name is the Aggregate Identity, Version is the version of the event stream, and Data is a blob, storing the serialized Domain Event. The implementation opens a connection to the database, executes a command, passing in the parameters, and commits the transaction. The IAppendOnlyStore implementation knows intimate details of the persistence mechanism. For a File-based implementation, it would probably know where the file is; for Azure, it would probably know credentials; for MongoDB it would probably know about the documents required.

The gap is that this seems like a leaky abstraction detail.

It feels like all of those intimate implementation details should be completely encapsulated within the IAppendOnlyStore implementation. It feels like only the implementation should know that the data is stored in a blob column in MySQL, and would therefore need to be serialized. However, this leaks out of the implementation into the Event Store. The responsibility of serializing and deserializing the Domain Event exists in the Event Store, not the IAppendOnlyStore.

This feels like the Event Store either knows, or is dictating, that the underlying persistence mechanism will store the Domain Event as a byte(). This feels wrong to me. If we wanted to persist the Domain Event properties as separate columns, in a normalized form in the database, the IAppendOnlyStore implementation should support that. It already supports different types of connections; it knows whether it’s executing a raw query or a stored procedure; whether one table is updated or multiple; so it should have the freedom to interact with the underlying mechanism in whatever way is necessary. This, to me, implies that it is actually the responsibility of the IAppendOnlyStore to serialize the Domain Event, not the Event Store, because the IAppendOnlyStore is the only component that knows, or should know, what the underlying persistence mechanism requires, in terms of format, datatype, and data shape. In this case, that the Domain Event is serialized as a byte(), and stored in a single blob column, in a single table. I’ll call this Assumption One.

With Assumption One in mind, it is also implied that deserialization is the responsibility of the IAppendOnlyStore, as it is the opposite pairing of serialization. If the IAppendOnlyStore is responsible for serializing an in-memory Domain Event instance, into a byte() for the underlying persistence mechanism, it seems reasonable that it would also have the responsibility of deserializing a byte() from the underlying persistence mechanism, into an in-memory Domain Event instance. I’ll call this Assumption Two.

With Assumption Two in mind, all transformation from in-memory object, to persisted object, and back, is the responsibility of the IAppendOnlyStore. Additionally, IAppendOnlyStore supports retrieving all, or some, events associated with a given Aggregate Identity. In the example in the book, the Event Store translates an IEnumerable<DataWithVersion> from the IAppendOnlyStore, into an EventStream containing a list of the deserialized events. With Assumption One and Two in mind, this would not be an operation on the Event Store, as that responsibility would lie with the IAppendOnlyStore.

So from one single feeling, that the IAppendOnlyStore should have exclusive knowledge of how a Domain Event is persisted, nearly all responsibility has been removed from the Event Store. It doesn’t deal with serialization; deserialization; enforcing strong typing; retrieving events, or appending them; translating from persistence object to in-memory object, or vice-versa. At this level, it’s delegating all of those concerns to the IAppendOnlyStore. All that’s left is concurrency protection, but even that seems more like a concern for the storage mechanism, than the Event Store.

Did I miss something? At this point, the only reason I can think of that would justify the existence of the Event Store, is to provide a non-storage/non-persistence/non-lowest-level oriented interface that indicates that an event is stored somewhere, somehow. It feels like its only purpose is to delegate calls to whatever instance of IAppendOnlyStore it’s been told to use, to relieve the client of knowing that it is interacting directly with the persistence mechanism.

Is there some other reason to keep these responsibilities in the Event Store that I missed from my reading of the book? Should the Domain Events really be serialized in the Event Store, as opposed to the persistence mechanism? Is it preferable for the Event Store to guarantee or enforce that the underlying mechanism persists events as serialized binary blobs?

database design – Event sourced persistence and data model refactoring

I’ve been working on a system that is using event-sourced persistence for it’s data model. It is using standard model of sequence of events with aggregates being rehydrated from those events and projections used for more complex queries.

One thing that has been bothering me lately is the question of refactoring. As we follow agile, incrmental way of building the system, it becomes innevitable that new features might result in changed to the data model. In this case, it would be the events need to change. One specific example is the case improved model domain splitting one event into two separate one, with properties of the original being split into the two events.

Currently, the system is using sub-optimal model of using only single event. This results in usage of teh aggregate being inconsistent, as it is forced to create event later instead of creating one event first and later creating second event with additional data. I’m thinking of refactoring this, but because we keep history of all events, it would result in having both single-event model and double-event model in history, which needs to be supported in both aggregate rehydration and projections. This would not reduce complexity, but just move it from point of creation of the events to the point of consumption of the events.

So I’m thinking about chaning the events history, but as we are using sequence numbers and version history, it is impossible to insert events into past and in between two other events of an aggregate. Only option that comes to mind is to create a full copy of the events store and transform the events from one into another. But that feels like really complex operation, as it needs two persistence stores to run at the same time, and software to support reading from both.

So I wonder if there is simpler way of doing this kind of refactoring?

nt.number theory – Reference request for Additive persistence of a number

It is well known fact that each natural number can be represented uniquely in any base. So we can define digit sum function whose value is sum of digits of the natural number in given base.

Let $f(n,b)$ be digit sum of n in base b. It is very easy to prove that for each n in natural number there exist a k such that $f^k(n,b)$ (function composition) is a digit in base $b$. The smallest such $k$ is called additive persistence of $n$.

Where I can find the research articles published on these topics? I am able to only find few articles in Research Gate and few other websites. Can you give references where this additive persistence is used or its properties are discussed?