HN user

matthavener

787 karma
Posts7
Comments166
View on HN

It's absolutely a zoning issue. The Texas legislature is literally overriding large cities to force them to allow smaller lot sizes. Most of Dallas, for example, is R-7.5, which drives up cost because land is expensive and it requires you to dedicate a lot of it to your yard (max 45% coverage). Only a few areas, like some PDs in old east Dallas, have been rezoned to allow the smaller lots, though you seem to believe its all of Dallas city limits.

https://www.texastribune.org/2025/06/01/texas-legislature-sm... https://developmentweb.dallascityhall.com/publiczoningweb/#d... https://dallascityhall.com/departments/sustainabledevelopmen...

NHTSA has a 25-year rule that allows a car old than 25 years to be imported without those considerations. You can definitely import them legally in Texas. I find it funny that we disallow these new smaller trucks, but we allow folks to jack up the suspension on an already large American truck 24 inches, install a grille guard, and it's still considered legal.

In clojure, you see something similar at the bottom of files:

  (comment
    (def some-state (create-state))
    (some-fn [1 2 3])
    (do-something some-state)
  )
The compiler ignores the block, but in a REPL enabled editor, you can evaluate the forms to possibly view current state, or run functions that test behaviors or probe runtime state.
C99 tricks 11 years ago

My favorite C99 trick:

    const char *lookup[] = {
      [0] = "ZERO",
      [1] = "ONE",
      [4] = "FOUR"
    };
    assert(strcmp(lookup[0], "ZERO") == 0);
(not available in C++ or pre-C99)

Yup, EC2 instances should be issuing a gratuitous arp on startup. I've seen the same thing on subnets with a lot of DHCP churn due to constantly rebooting embedded devices.

I'm making some assumptions about the compiler optimization: If T is something like "int", then passing by reference can be more costly, because a value that was once stored in a register now needs a real memory address and must be deferenced to read.

I didn't quite "get" the point of the pointer/copy option on interfaces, but this makes it crystal clear. This works around such a common problem in writing C++ templates (which is really the only equivalent polymorphism if you want to dispatch a function on a native type):

  template <class T> void doSomething(const T &expensiveCopy);
Versus:
  template <class T> void doSomething(T cheapCopy);
As usual, boost provides another crazy template hack to work around this issue:

http://boost.sourceforge.net/libs/utility/call_traits.htm

  ;; especially since read-string will be fixed in clojure 1.5 so that
  ;; binding *read-eval* to false around it will make it safe, as far as
In clojure 1.5 with read-eval bound to false, the reader is still unsafe for malicious input. Since the Clojure reader must be able to construct arbitrary Java objects via their constructors, any constructor can be called from the reader even with read-eval bound to false.

In C++, you can do this by passing the array by reference:

    void foo(int (&foo)[10]) {}
However, that is not "minimum of 10" but "exactly 10".

You can also get the size at compile time:

    template <size_t N> void foo(int (&foo)[N]) { int newarry[N+2]; }
I've used the above for something like this:
    template <size_t N> void safe_strcpy(char (&buf)[N], const char *src) { 
      strncpy(buf, src, N-1); 
      buf[N-1] = 0; 
    }