For many small domains Reseller vs VPS & HFW Mess of 2018 solved?

Have a reseller account at the lowest level with HFW (Host for Web) for about 25 years. Since their chaos in January 2018 with sites and emails for days (as discussed here, including me on a thread), I have been looking for a new host which has led me to good reviews for Hostwind . But I'm not a geek and I haven't had time and I don't want to face complications (they will be transferred for free).

As far as HFW is concerned, it looks like they moved from Chicago to New York and the recent reviews seem pretty good. So I plan to stay with them and no major problems in recent years.

I have around 30 domains via Namecheap, around 20 active in a reseller account with HFW, but they are all mine. Low traffic and still a lot of unused space with 100 GB of storage. WHM global and Cpanel for each area. Some that I haven't updated in years (I loved the ease of Frontpage for years, everything was done online, never used FTP, etc.) – but under the limit of 1 TB.

Whether I stay with HFW or go to Hostwinds, is there really a great ease of use to go to a managed VPS reseller vs a current reseller? I know an advantage is my own IP over shared and a few times a bad user on my shared IP has caused a blacklist, but not for years. I can't quite get the concept of VPS with many domains to manage via Cpanel vs VPS separate with one?

I'm a little scared to make the change because I don't have time to be a technician or the knowledge related to domain management. Although I come from the era of switches and 60 baud packet readers and Usenet before websites as well as Wang OS2 and even before card sorters before floppy disks and early hard drives about 3 feet in diameter! (old man)

Speaking also to Hostwinds, they suggested that I really needed 4 GB of memory with as many domains against 2, which I think is what I now have with the reseller. Does this make sense?

My MacBook Pro 2018 Touch Bar refuses to turn on

So I slept with the MBP plugged into power. When I woke up and tried to turn it on, it didn't work. I tried to click on the touchpad and it is responsive.

Holding the power button down does not help, the touch bar instead displays a red light for a fraction of a second.

I also tried the shift + control + option + power button without success

crash – Mac Mini 2018 freezes under load

I just bought a brand new Mac mini 2018 (i5, 32 GB RAM, 256 GB SSD) and it started kernel panicking (I guess it stops coming out on the screen and the fan becomes very strong for one second, the LED stays on and I have to hold it for 10 seconds to restart it). This happens pretty much under load, which is a shame because I have to use it under load.

I would like to attach the crash log, but it seems to be too long for StackOverflow.

Four automotive trends to watch in 2018

2017 was a very interesting year for the automotive industry and everything that happened both in the open and behind the scenes. To see carpool companies continue to grow, car sales to decrease and autonomous vehicles to hit the road, it was surely historic.
2018 should be no different. Here are four List of telephone numbers automotive trends to watch for in the coming months and 2018 as a whole.
1. Electric vehicles – 2018 is going to be a very exciting year for electric vehicles as they have finally gained ground in the industry. New options will be available with models that offer longer driving ranges and will be cheaper. Charging times will continue to decrease and charging stations will start to appear more and more around the main highways and cities. As the world continues to push more towards a healthier environment, the rise of electric vehicles will continue to grow. Outside the United States, other countries have already started implementing this change and are making electric vehicles their number one priority and their first transportation option.
2. Car sales – For the first time in seven years, car sales in the United States have declined. While this shouldn't be a huge red flag, some people are wondering what the future holds. As carpooling services become more accessible and cars are still expensive, more and more people are choosing not to own a vehicle. Experts predict sales will go well in 2018, but it will be interesting to see how the major automakers will fare in the new year.
3. Carpoolers – Carpoolers have taken the transportation industry by storm and really [Image: Indian-B2B-Phone-List.jpg]had an impact on the way people move. They offer such a simple way to request a ride and an easy way to pay, which makes trips faster and cheaper overall. The two carpool giants, Uber and Lyft, have also introduced extensive programs such as how to treat people with visual impairments and even how to get patients to their medical appointments. If these efforts continue, carpooling companies will remain present for a long time. It will be interesting to see what they have in store for 2018.
4. Driverless Vehicles – With electric vehicles, driverless vehicles are fast becoming the next big thing. Once considered a mere dream, they are now becoming a reality. In 2017, driverless vehicles traveled physical kilometers on the roads and new and improved technologies. Large companies around the world are investing in these new standalone security features, hoping to improve them. So far, we've seen driverless vehicles on the roads of California and Michigan and they don't seem to stop anytime soon. Driverless vehicles are believed to make roads almost 95% safer than they currently are.

macos – Anti-aliasing of subpixels not respected by Outlook 2018

I just updated Mojave …

I am using an external non-retina screen with my Macbook Pro 2018, so make sure that the font smoothing is checked in the settings and that I have run

defaults write -g CGFontRenderingFontSmoothingDisabled -bool NO

it improved the whole text, except in Outlook (16.32) where it made no difference. Google has found no indication as to whether Outlook is doing something weird. I tried to settle defaults -currentHost write -globalDomain AppleFontSmoothing -int 3 also but in vain.

Can I try something else?

enter description of image here

What is the best cryptocurrency in which to invest right now in June 2018 – Cryptocurrency Corner

Visit for Free Crypto Signal and Daily Profit through a Bitmex Dynamic BOT – https://t.me/freebitmexsignals

Here is a live Bitmex statement shared by one of the Bitmex Bot users. These are statements that are never shared by any community. These are real profits that make our signals and our automatic trading very special. Nearly $ 1000 in earnings in just 3 days – Amazing!

13% profit on #TRX via a scalping trade executed via BOT – this is how Bitmex Dynamic Bot realizes profits!

These are high quality transactions, the best part is that all of these transactions are automatically executed on your account via automated bot. We also provide free signals for a free user.

Visit us and receive free Bitmex signals every day; its accuracy is 96%.

.

Beginner – Advent Of Code 2018 Day 15 – Naive Rust Program

I have solved the problem of the advent of the code last year in Python and I wanted to learn a new language this year. I have therefore decided to write part 1 of one of the most difficult problems of last year – the problem 15 – to Rust.

It's a bit long and we could probably simplify it by using external crates, but I decided not to do it to help me learn. As far as I know, this program is 100% correct in all its details – it has provided the correct answer for my entry and some others that I have tested. It uses BFS to calculate the correct movements for each unit, which, in my opinion, is a sufficient algorithm, and fast enough to meet the needs of the problem.

What I'm really looking for is to make this code more idiomatic, because I just read Rust's book and navigated the writing of this code. I'm not sure that I have to get a copy and / or a clone for many of these guys, it sounds a bit "misleading", and the code structure is also a bit more clumsy than necessary. to be, but to fight with the loan checker means some difficulty in solving this problem. Thanks in advance!

use std::env;
use std::fs;
use std::fmt;
use std::error::Error;
use std::collections::{BTreeMap, BinaryHeap, HashSet};
use std::cmp::{Ordering, Reverse};
use unit::*;

pub fn main() -> Result<(), Box> {
    let args = env::args().collect::>();

    let input_filename = match args.len() {
        2 => &args(1),
        _ => "input.txt"
    };

    let string_grid = fs::read_to_string(input_filename)?;

    let mut combat_grid = parse_input(&string_grid)?;
    let mut full_rounds: usize = 0;

    println!("Start");
    print!("{}", combat_grid);
    println!("n");

    while combat_grid.tick() {
        full_rounds += 1;
        println!("n");
        println!("Round {}", full_rounds);
        print!("{}", combat_grid);
        println!("n");
    }

    println!("Final");
    print!("{}", combat_grid);
    println!("n");

    println!("Outcome: {}",
        full_rounds  * combat_grid.units.values().map(|u| u.hp).sum::());

    Ok(())
}

fn parse_input(string_grid: &str) -> Result {
    let mut grid = BTreeMap::new();
    let mut units = BTreeMap::new();
    let mut dimensions = (0, 0);

    for (y, row) in string_grid.lines().enumerate() {
        dimensions.1 += 1;

        for (x, character) in row.chars().enumerate() {
            dimensions.0 += 1;

            let current_location = Location { x, y };

            grid.insert(current_location, match character {
                "https://codereview.stackexchange.com/#" => Environment::Wall,
                '.' => Environment::Open,
                'G' | 'E' => {
                    units.insert(current_location, Unit {
                        team: if character == 'G' { UnitTeam::Goblin } else { UnitTeam::Elf },
                        location: current_location,
                        hp: 200,
                        attack_power: 3
                    });

                    Environment::Open
                },
                _ => {
                    return Err(format!("Invalid input character: {}", character));
                }
            });
        }
    }

    Ok(CombatGrid { grid, units, dimensions })
}

#(derive(Eq, PartialEq, Copy, Clone, Hash))
pub struct Location {
    x: usize,
    y: usize
}

impl Location {
    fn adjacent(&self) -> (Self; 4) {
        return (
            Location { x: self.x, y: self.y - 1 },
            Location { x: self.x, y: self.y + 1 },
            Location { x: self.x - 1, y: self.y },
            Location { x: self.x + 1, y: self.y }
        );
    }
}

impl fmt::Debug for Location {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

impl Ord for Location {
    // This implements the "reading order" requirement
    // used in breaking lots of ties.
    fn cmp(&self, other: &Self) -> Ordering {
        if self.y != other.y {
            self.y.cmp(&other.y)
        } else if self.x != other.x {
            self.x.cmp(&other.x)
        } else { Ordering::Equal }
    }
}

impl PartialOrd for Location {
    fn partial_cmp(&self, other: &Self) -> Option {
        Some(self.cmp(other))
    }
}

pub struct CombatGrid {
    grid: BTreeMap,
    units: BTreeMap,
    dimensions: (usize, usize),
}

impl fmt::Display for CombatGrid {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        for y in 0..self.dimensions.1 {
            let mut row_units = Vec::new();

            for x in 0..self.dimensions.0 {
                let location = Location { x, y };

                if let Some(unit) = self.units.get(&location) {
                    write!(f, "{:?}", unit.team)?;
                    row_units.push(unit);
                } else if let Some(env) = self.grid.get(&location) {
                    write!(f, "{:?}", env)?;
                }
            }

            write!(f, "t")?;

            for unit in row_units {
                write!(f, " ({:?}) ", unit)?;
            }

            write!(f, "n")?;
        }

        Ok(())
    }
}

impl CombatGrid {
    pub fn tick(&mut self) -> bool {
        for unit_location in self.units.keys().cloned().collect::>().iter() {
            // This unit may have since died by the hands of another
            // by the time we have gotten to it, so check if it's still there.
            let unit = match self.units.get(unit_location) {
                Some(unit) => unit.clone(),
                None => continue
            };

            let enemy_units = self.units
                .iter()
                .filter(|(_, u)| u.is_enemy(&unit))
                .map(|(l, u)| (l.clone(), u.clone()))
                .collect::>();

            if enemy_units.len() == 0 {
                return false; // Combat has ended, one team has won.
            }

            if let Some(attacked_unit_location) = unit.possible_attack(&enemy_units) {
                self.attack_unit(unit_location, &attacked_unit_location);
                continue;
            }

            if let Some(move_location) = unit.possible_move(&enemy_units, |l| self.is_open_fn(l)) {
                // Get the new Unit with the updated location. The old reference is stale
                // otherwise, leading to attack behaviour based on the old location, which never
                // actually works out, because the only reason any unit moves is because its
                // old location is not adjacent to any enemy unit.
                let unit = self.move_unit(unit_location, &move_location);

                if let Some(attacked_unit_location) = unit.possible_attack(&enemy_units) {
                    self.attack_unit(&move_location, &attacked_unit_location);
                }
            }
        }

        true
    }

    fn attack_unit(&mut self, current_unit_location: &Location, attacked_unit_location: &Location) {
        let current_unit = &self.units(current_unit_location).clone();
        let mut attacked_unit = self.units.get_mut(attacked_unit_location).unwrap();

        // This protects against overflows in the usize
        attacked_unit.hp =
            attacked_unit.hp.saturating_sub(current_unit.attack_power);

        if attacked_unit.is_dead() {
            self.units.remove(attacked_unit_location);
        }
    }

    fn move_unit(&mut self, current_unit_location: &Location, new_location: &Location) -> Unit {
        let new_location = new_location.clone();
        let mut current_unit = self.units.remove(current_unit_location).unwrap();

        current_unit.location = new_location;
        self.units.insert(new_location, current_unit.clone());

        current_unit
    }

    fn is_open_fn(&self, location: &Location) -> bool {
        if self.units.contains_key(location) {
            false
        } else if let Some(env) = self.grid.get(location) {
            env == &Environment::Open
        } else { false }
    }
}

#(derive(Eq, PartialEq))
pub enum Environment {
    Wall,
    Open
}

impl fmt::Debug for Environment {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", if self == &Self::Wall { "https://codereview.stackexchange.com/#" } else { '.' })
    }
}

mod unit {
    use super::*;

    #(derive(Eq, PartialEq, Copy, Clone))
    pub enum UnitTeam { Goblin, Elf }

    impl fmt::Debug for UnitTeam {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write!(f, "{}", if self == &Self::Elf { 'E' } else { 'G' })
        }
    }

    #(derive(Eq, PartialEq, Clone))
    pub struct Unit {
        pub team: UnitTeam,
        pub location: Location,
        pub hp: usize,
        pub attack_power: usize
    }

    impl fmt::Debug for Unit {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write!(f, "{:?}({}) @ {:?}", self.team, self.hp, self.location)
        }
    }

    impl Unit {
        pub fn is_enemy(&self, other: &Self) -> bool {
            self.team != other.team
        }

        pub fn is_dead(&self) -> bool {
            self.hp == 0
        }

        pub fn possible_attack(&self, enemy_units: &BTreeMap) -> Option {
            let mut adjacent_enemy_units = enemy_units
                .values()
                .filter(|u| self.location.adjacent().contains(&u.location))
                .collect::>();

            adjacent_enemy_units.sort_unstable_by(|a, b| {
                match a.hp.cmp(&b.hp) {
                    Ordering::Equal => a.location.cmp(&b.location),
                    hp_cmp => hp_cmp
                }
            });

            adjacent_enemy_units.reverse();
            adjacent_enemy_units.pop().map(|u| u.location)
        }

        pub fn possible_move(
            &self,
            enemy_units: &BTreeMap,
            is_open_fn: impl Fn(&Location) -> bool
        ) -> Option {
            let mut frontier = self.location.adjacent()
                .iter()
                .cloned()
                .filter(|l| is_open_fn(l))
                .map(|l| Reverse(SearchNode {
                    distance: 1,
                    current_location: l,
                    starting_location: l,
                }))
                .collect::>();

            let mut explored: HashSet = HashSet::new();

            while let Some(Reverse(next)) = frontier.pop() {
                for next_adjacent in next.current_location.adjacent().iter().cloned() {
                    if explored.contains(&next_adjacent) { continue; }

                    if !is_open_fn(&next_adjacent) {
                        if enemy_units.contains_key(&next_adjacent) {
                            return Some(next.starting_location);
                        }

                        continue;
                    }

                    frontier.push(Reverse(SearchNode {
                        distance: next.distance + 1,
                        current_location: next_adjacent,
                        starting_location: next.starting_location
                    }));

                    explored.insert(next_adjacent);
                }
            }

            None
        }
    }

    // Private helper to make possible_move easier to keep track of
    #(derive(Debug, Eq, PartialEq, Copy, Clone))
    struct SearchNode {
        distance: usize,
        current_location: Location,
        starting_location: Location,
    }

    impl Ord for SearchNode {
        fn cmp(&self, other: &Self) -> Ordering {
            if self == other { return Ordering::Equal; }

            match self.distance.cmp(&other.distance) {
                Ordering::Equal => {
                    match self.current_location.cmp(&other.current_location) {
                        Ordering::Equal => self.starting_location.cmp(&other.starting_location),
                        current_location_cmp => current_location_cmp
                    }
                }
                distance_cmp => distance_cmp,
            }
        }
    }

    impl PartialOrd for SearchNode {
        fn partial_cmp(&self, other: &Self) -> Option {
            Some(self.cmp(&other))
        }
    }
}

Macbook Pro 2018, trackpad problem due to a swollen battery or a defective trackpad?

I have a weird trackpad problem on my Macbook Pro 15 "2018 for a few days now, I guess this is due to a swollen battery, but I'm not quite sure.

Here is the problem:

  • Force Click almost never works, if not only a few minutes after starting in the morning
  • the right click (two-finger click) works fine for a while after starting, then stops working on a part or trackpad after a while
  • the more I use the computer, the larger the area where I can not right-click, starting from the top down and extending downward
  • after a few hours, I can only right-click on the sides and lower third of the trackpad and sometimes even a single click (click of a finger) does not work in the central upper part trackpad

Since the problem worsens depending on the length of time the computer is used, I think it is a hardware and non-software issue.
Resetting SMC and NVRAM + PRAM did not help.

I then noticed that my battery may have been swollen. At least, the lower part of the device is as light as a slight pressure on the lower right side that lifts the upper left rubber side a few millimeters, as on the other side.
To be clear, the trackpad itself seems perfectly flat, but the bottom of the computer seems bloated.

However, I am not totally convinced that it is the battery, because System Report seems to consider it as healthy.
In addition, I'm not sure that an inflated battery could affect the trackpad, because if I understood it well, on the most recent trackpads, the clicks are not mechanical, but generated by pressure sensors.

I can not get my computer installed from an authorized Apple service provider (no official Apple store in my area) for a few days / a week and I also got out of warranty about 2 months ago .
So I turn to a battery exchange to get an opinion on the problem and see if the device can still be used safely for a while, as seemingly inflated batteries are potentially dangerous.

Geometry – How can I always get an option of coordinates of points A, B, C, D and X of Problem 6 in the IMO 2018?

That's the problem 6 of the IMO 2018 https://www.imo-official.org/problems.aspx

enter the description of the image here

I use the code to MaplePrimes (with some prepairs) https://www.mapleprimes.com/questions/228162-How-Can-I-Get-One-Option-Opo-Coordinates

a = {0, 0};
b = {5, 0};
c = {3, 4};
d = {15 - 4*Sqrt(19), 6};
x = {-172*Sqrt(19)*(1/757) + 1839/757, 2762/757 - 176*Sqrt(19)*(1/757)};

I've checked the conditions and all are true.

EuclideanDistance(a, b) * EuclideanDistance(c, d) - 
  EuclideanDistance(a, d) * EuclideanDistance(c, b) // Simplify

VectorAngle(a - x, a - b) - VectorAngle(c - x, c - d) // Simplify

VectorAngle(b - x, b - c) - VectorAngle(d - x, d - a) // FullSimplify

But, when I change coordinates of a point A, B, C, then sometimes, I can not get the result.

How can I still get an option for coordinates of points A, B, C, D and X of Problem 6 in the IMO 2018?

Search Engine Optimization SEO Courses & Training Singapore

Learning to SEO is one of the new skills to be taken with great importance during this decade. There are many other digital marketing skills that you should learn. There is Google Adwords, Google SEO, Facebook Marketing, Instagram Marketing, Email Marketing, Linkedin Marketing. What we will suggest is to acquire most of these skills, because in the 21st century, if you have more marketing skills, especially online marketing, you can expect a lot of demand. Digital marketing is now the key to getting your prospects to reach your products or services.
SEO is a skill that many people will take over time with those who can do other forms of digital marketing. Ranked among the top 10 skills to acquire in 2018 by Linkedin, it 's certainly a skill that we believe is not important. Most employers will want you to have the opportunity to do so. The search is always topical and the internet will always require the best SEOs for the ranking to run smoothly, so you can get a strong brand and tracks for the rest of the world to find you.

To learn more about our course, check out the ==> seogeek singapore

MattBurditt1
Review by MattBurditt1 sure
.
Search Engine Optimization SEO Courses & Training Singapore
Learning to SEO is one of the new skills to be taken with great importance during this decade. There are many other digital marketing skills that you should learn. There is Google Adwords, Google SEO, Facebook Marketing, Instagram Marketing, Email Marketing, Linkedin Marketing. What we will suggest is to acquire most of these skills, because in the 21st century, if you have more marketing skills, especially online marketing, you can expect a lot of demand. Digital
Evaluation: 5

.