Similar URLs for two different pages hurt SEO, if pages offer different information?

I have written a guide to a particular subject, and it’s over 6000 words. I decided to split up the information into two separate pages, as the information really falls under two categories for end users, but they have the same parent category.

For example

  • /beginners-guide-kayaks-enthusiasts – Beginners Guide to Kayaks for Enthusiasts
  • /beginners-guide-kayaks-fishermen – Beginners Guide to Kayaks for Fishermen

The content is so long, fitting them onto a single page with images would be overwhelming to anyone clicking on the page. So I decided to go with two separate pages.

Each page has completely different information, but as you can see, the page titles and resulting URLs would be really close to each other. Will this hurt my SEO by having two very close URLs?

Is there a better way to handle this?

If passwords are stored hashed, how would a computer know that your password is similar to the last one if you try resetting your password?

If passwords are stored hashed, how would a computer know that your password is similar to the last one if you try resetting your password? Wouldn’t the two passwords be totally different since one is hashed, and unable to be reversed?

Can chain lightning (and perhaps, spells with similar wording) target worn or carried equipment?

Chain lightning can specifically target objects and does not specify that the object must be unattended; spells like fireball or lightning bolt do. Does this mean its secondary targets can be objects worn or carried by the initial target creature? Can the initial target be an object worn or carried by a creature? What about any combination of these?

You create a bolt of lightning that arcs toward a target of your choice that you can see within range. Three bolts then leap from that target to as many as three other targets, each of which must be within 30 feet of the first target. A target can be a creature or an object [no specification unattended or otherwise] and can be targeted by only one of the bolts.

A target must make a Dexterity saving throw. The target takes 10d8 lightning damage on a failed save, or half as much on a successfully one. (PHB p. 221, emphasis mine.)

Dealing 10d8 damage to up to three worn or carried objects after zapping the creature seems to be a really effective way to use this spell; it would probably break things you don’t want your enemy to use and deal him a good chunk of damage. This potential use of the spell, its expected damage output, and the comparatively low HP of objects suggested in the DMG make for a potentially pretty electrifying attack.


Related, though I couldn’t find an answer here.

How does the Chain Lightning spell target?

This one’s accepted answer does address areas of effect, though I think chain lightning is different enough to warrant my question.

What qualifies for the target of a spell?

Is there a web API, similar to Google Places, that provides contact emails?

I’m trying to build a list of local contacts from about 500 businesses. Using Google Places API, I was able to generate numerous phone numbers and addresses.

However, Places doesn’t offer email addresses. I assume this is because of spam reasons, but there are offer contact addresses on their websites. If they’re willing to put it out there, they are willing to receive emails.

Is there an API where you can pass in either a business name or address, and known contact details, including email addresses are included?

C# Class for handling Player Movement and / or similar behaviour

I am currently developing a unity-based multiplatform game (PC, IOS, Android) in a small team. This is the code we have created for the Character Actions inside the game. I am looking for feedback on the code itself as well as tips on how some Unity features could be used better. This is my first time developing a game with Unity.

The Game is also aimed for Mobile platforms as state above, so tips on optimization are welcome.

using AI.Enemy; using UnityEngine;  namespace Player.Script.Miru {     public class MiruScript : MonoBehaviour     {     public float Health;     public float MoveSpeed;     public float JumpHeight;      public float EvadeSpeed;     public float DefendCooldownTimer;     public float NormalDamage;     public float Cooldown;     public float Stamina;     public float HealthRegenerationRate;     public float StaminaRegenerationRate;      private bool _IsFacingForward;     private bool _IsGrounded;     private Rigidbody2D _RigidBody;     private RaycastHit2D _GroundDetector;     private RaycastHit2D _RightRayCast;     private RaycastHit2D _LeftRayCast;     private MinionScript _MinionScript;      private void Start() //Temporary values     {         MoveSpeed = 4f * Time.deltaTime;         JumpHeight = 10f;         EvadeSpeed = 5f;         DefendCooldownTimer = 0f;         NormalDamage = 50f;         Cooldown = 1f;         Stamina = 100f;         Health = 100f;         HealthRegenerationRate = 0.5f;         StaminaRegenerationRate = 10f;         _RigidBody = GetComponent<Rigidbody2D>();         _MinionScript = GetComponent<MinionScript>();     }      private void Update()     {         MoveRight(MoveSpeed);         MoveLeft(MoveSpeed);         Jump(JumpHeight);         Evade(EvadeSpeed);         Attack(NormalDamage);         DistanceFromObject();         AttackCooldown();         Defend();     }      private bool AttackCooldown()     {         if (Cooldown < 1f)         {             Cooldown += Time.deltaTime;             return true;         }          return false;     }      public int DamageDealt(float _damageDealt)     {         Health -= _damageDealt;          if (Health <= 0)             Destroy(gameObject);          return 0;     }      private int DistanceFromObject()     {         _RightRayCast = Physics2D.Raycast(transform.position, Vector2.right);         _LeftRayCast = Physics2D.Raycast(transform.position, Vector2.left);          if (_RightRayCast.distance < 1.5f && _LeftRayCast.distance < 1.5f)             return 3;          if (_RightRayCast.distance < 1.5f)             return 1;          if (_LeftRayCast.distance < 1.5f)             return 2;          return 0;     }      private int Attack(float _damageDealt)     {         if (_IsFacingForward && Input.GetKeyDown(KeyCode.X) && _RightRayCast.distance <= 1.5f && !AttackCooldown())         {             _MinionScript = _RightRayCast.collider.gameObject.GetComponent<MinionScript>();             _MinionScript.DamageDealt(_damageDealt);             Cooldown = 0;             return 1;         }          if (_IsFacingForward == false && Input.GetKeyDown(KeyCode.X) && _LeftRayCast.distance <= 1.5f && !AttackCooldown())         {             _MinionScript = _LeftRayCast.collider.gameObject.GetComponent<MinionScript>();             _MinionScript.DamageDealt(_damageDealt);             Cooldown = 0;             return 2;         }          return 0;     }      private int MoveRight(float _moveSpeed)     {         if (Input.GetKey(KeyCode.RightArrow) && Defend() == 0)         {             transform.Translate(_moveSpeed, 0, 0);             _IsFacingForward = true;             return 1;         }          return 0;     }      private int MoveLeft(float _moveSpeed)     {         if (Input.GetKey(KeyCode.LeftArrow) && Defend() == 0)         {             transform.Translate(-_moveSpeed, 0, 0);             _IsFacingForward = false;             return 1;         }          return 0;     }      private int Jump(float _height)     {         _GroundDetector = Physics2D.Raycast(transform.position, Vector2.down);          if (Input.GetKeyDown(KeyCode.Z) && _IsGrounded)         {             _RigidBody.AddForce(Vector2.up * _height, ForceMode2D.Impulse);             return 1;         }          if (_GroundDetector.distance > 0.6f)         {             _IsGrounded = false;             return 2;         }          _IsGrounded = true;         return 0;     }      private int Evade(float _evadeSpeed)     {         if (Input.GetKeyDown(KeyCode.Space) && _IsGrounded)             switch (DistanceFromObject())             {                 case 1:                     _RigidBody.AddForce(Vector2.up * _evadeSpeed, ForceMode2D.Impulse);                     _RigidBody.AddForce(Vector2.left * _evadeSpeed, ForceMode2D.Impulse);                     return 1;                  case 2:                     _RigidBody.AddForce(Vector2.up * _evadeSpeed, ForceMode2D.Impulse);                     _RigidBody.AddForce(Vector2.right * _evadeSpeed, ForceMode2D.Impulse);                     return 2;                  case 3:                     _RigidBody.AddForce(Vector2.up * _evadeSpeed * 3, ForceMode2D.Impulse);                     return 3;             }          return 0;     }      private int Defend()     {         if (Input.GetKey(KeyCode.Space) && _IsGrounded)         {             DefendCooldownTimer += Time.deltaTime;             if (DefendCooldownTimer >= 0.5f)             {                 return 1;             }         }         else             DefendCooldownTimer = 0f;          return 0;     } } } 

Design pattern for similar classes that require different implementations

There could be a common or best practice for this scenario, but I am unfamiliar with it. However, it could very easily be a matter of subjective opinion on how one wants to implement their classes. Either way I am hopefuly to get some opinion from the spectrum of class designers here.

I am currently working on a project that allows users to generate files for data visualization.

The library will support two file types that are formatted differently (binary and XML). Due to this, I am left with a dilemma on how I want to control class instantiation and API access:

  1. Create a separate class for each file type and visualization type
  2. Create a separate class for each visualization type and load with methods for each file type
  3. (Not demonstrated) The inverse of Option 2

Option 1:

class Base:     # Stuff class F1V1(Base):     # Methods specific to file and visualization type one class F1V2(Base):     # Methods specific to file type one and visualization type two class F1V3(Base):     # Methods specific to file type one and visualization type three class F2V1(Base):     # Same logic as before but for file type two class F2V2(Base):     # ... class F2V3(Base):     # ... 

Here a user of the library would call their direct class to perform operations specific to it without the need of setting keyword parameters to determine what it does (e.g. fv = F1V2())

What is great about this way is that its explicit, a user knows exactly what file and visualization type they are working with. But I think its cumbersome and not extensible in the event I want to add more file or visualization types; forcing me to write a new class for each possible combination.

Option 2:

class Base:     # Stuff class V1(Base):     def __init__(self, ftype_1=True)         self.ftype_1 = ftype_1     def write(self):         if self.ftype_1:             # Write method specific to file type one         # Write method specific to file type two     # Assume 3 methods for each operation     # One method such as `write()`     # One method for each of the file types class V2(Base):     # Same logic as before class V3(Base):     # ... 

What I don’t like about this method is that I now have to define multiple methods for each class that execute based upon keywords provided at construction (i.e. fv = V2(ftype_1=False)). Ideally, what I would like is to supply a keyword argument that then determines which of the methods should belong to that class. For example:

fv = V2() # Only contains methods to file type one operations fv = V2(ftype_1=False) # Only contains methods to file type two operations 

As shown, there is nothing that prevents the following:

fv = V2() # Set for file type one fv.write_ftype_2() # Will produce an invalid file type formatting 

I am not sure of a way where I can dynamically bind/remove methods based upon keyword arguments. It would be great if I could simply write all the methods for each file type within each visualization type, then remove methods that are not relevant to the class anymore. Im not sure if this is even advisable, I can already think of a scenario like so:

def write(self):     if self.ftype_1:         # Write method specific to file type one     elif self.type_2:         # ...     else:         # ... 

If I dynamically removed methods from a class based upon keyword arguments, what would the point of the conditions be if say the first one held?

Summary:

So which is a common or best practice? Which can be improved? Or am I missing another way?

An ideal example would be (in my mind):

fv = Hexagons(ftype='.abc', flat=True, area=3) fv.insert(data) fv.write(data) # Specifically writes for file types of '.abc' 

I suppose I could make Hexagons() return a subclass via __new__ but I think that might be unclear as to what is happening. To call Hexagons() but receive a ABCHexagons object could lead to confusion when users inspect the code base.

A factory method is ideal for this, but that is simply class instantiation. But each visualization type may have a variety of different keyword parameters that may not apply to the others. Rather, my issue lies with how to define them in the code base which ultimately leads to solving how to expose them to users.

Should libraries be packaged together based on similar traits? Nuget

I just started a new job and one of my first tasks is to create local nuget packages from the existing libraries, to help with versioning, maintenance, etc. This task had already been started by another engineer. However, he chose to grab many libraries that relate, create a project holding all these libraries, and publish it as one package (specifically a nuget package).

Example: LibraryA_v1 + LibraryB_v2 + LibraryC_v3 = PackageA_v1 LibraryB_v1 + LibraryC_v3 = PackageB_v2 

Then, PackageA_v1 and/or PackageB_v2 would be referenced by whatever project that needs them. However, I see a lot of different problems with this approach.

  1. PackageA_v1 and PackageB_v2 are extremely unstable. Anytime a library changes, the package would need to update.
  2. Since the packages are unstable, it is highly likely that the principle “Depend upon packages whose I metric is lower than yours” would be broken.
  3. I can’t seem to access the libraries within the packages (in a simple C# test application), which was the original intent.
  4. The last problem I see is that libraries of different versions could be imported into the same project, possibly causing problems (ex. LibraryB_v1 and LibraryB_v2 would be in the same project, if PackageA_v1 and PackageB_v2 are both referenced)

From my studies in software engineering and the principle previously mentioned, I think each library should be kept separate in their own nuget packages. However, my co-worker had obviously thought differently. So, should libraries be packaged together based on similar traits?