> If you have a one-line function that is used one place (or even a few places) and it doesn't mean it is easier to understand just because you made it look like English. More likely you just obfuscated it: update_string_with_value(string,val) is NOT easier to understand than string.append(val).

We agree your sample has been obfuscated.

  /// <summary>
  /// Case Insensitive IRC Name
  /// </summary>
  public struct CIIrcName {
  	private string Data;
  
  	public static implicit operator CIIrcName( string s ) { return new CIIrcName() { Data=s }; }
  	public static implicit operator string( CIIrcName n ) { return n.Data; }
  
  	public string ToLower() { return (Data??"").ToLowerInvariant().Replace('{','[').Replace('}',']').Replace('|','\\'); } // Silly scandinavians :<
  
  	public static bool operator==( CIIrcName lhs, CIIrcName rhs ) { return lhs.ToLower() == rhs.ToLower(); }
  	public static bool operator!=( CIIrcName lhs, CIIrcName rhs ) { return lhs.ToLower() != rhs.ToLower(); }
  
  	public override bool Equals( object obj ) { return obj is CIIrcName && (CIIrcName)obj == this; }
  	public override int GetHashCode() { return ToLower().GetHashCode(); }
  	public override string ToString() { return Data; }
  }

Every single function of this is a one-liner. Are any of them obfuscated? (IRC servers sometimes talk about the same user or channel in multiple cases, this was a quick drop-in to prevent these from being mistaken as different users/channels by my IRC client. The "Silly scandinavians" comment references the fact that, yes, IRC thinks '[' is lowercase '{'. And yes, I've seen that matter in practice.)

Most of the changes I'd make here have nothing to do with method length:

1) Conversion (at least back to string) should probably be made explicit at this point (was originally implicit for ease-of-use when replacing string s)

2) ToLower could be made private (only used inside the type) and have the comment replaced with the above blurb (instead of being a comment to myself that only I'll properly decode.)

3) Rename CIIrcName to CaseInsensitiveIrcName?

4) Rename Data to OriginalCaseName?

> And you're also coding defensively against your fellow developers. This tends to be a problem in low- to average-skill workplaces.

My experience has been just the opposite. Low/average skill tends to mean less asserts, less static analysis, ignored warnings instead of warnings-as-errors, no unit tests, no thread safety annotations... forget my coworkers - I add these things to code defensively against future-me, and I've found it super effective on larger codebases.

> This goes all the way back to when they learned it was a good idea to comment their code "next = ++i // increment index then assign".

We agree this is bad too. A different perspective though - those are perfectly reasonable comments when you're new enough to programming that you don't remember what "++i" does! But it's something to grow out of and remove.