Uno de esos problemas en los que no es necesario saber de análisis reticular, basta con saber sumar y restar
set root=(hd1,1)
find /
chainloader +1
boot
"...si la secuencia en verdad no tiene fin (y no se repite cíclicamente, añado yo) esto implica que cualquier número imaginable, e incluso cualquier combinación de ellos, aparecerá más tarde o más temprano en alguna parte de la secuencia de Pi. O de cualquier otro número irracional"
"Todos los libros escritos y por escribir, verdaderos y falsos, con errores y sin ellos; incluyendo el detallado manual de cómo descodificarlos, el catálogo completo (el verdadero y millones de ellos falsos), y la cuidadosa y convincente refutación de todos (incluyendo el auténtico). Todas las cartas de amor jamás escritas, las todavía por escribir, las que se pensaron y nunca llegaron al papel; todos los pensamientos expresados con palabras en todos los idiomas, muertos, vivos o todavía no nacidos… Todo está en algún rincón de Pi"
sudo update-rc.d -f qpidd remove
sudo update-rc.d -f qpidd defaults
sudo invoke-rc.d qpidd start sudo invoke-rc.d qpidd stop sudo invoke-rc.d qpidd restart
I must say that the lack of static typing really gets in the way on larger projects. Being able to confidently change datatypes and function signatures, knowing that the compiler will point out most inconsistencies that you introduce, is something that I've really come to appreciate after working with Rust and Haskell. Test coverage helps, of course, but I'm not a very diligent test writer, and tend to feel that type signatures are easier to maintain than an exhaustive test suite.Surprise, surprise, basically he's reiterating my simple argument: why should we give up something that can help us, i.e. automatic checking if all the interfaces are used correctly?
Right off, I can say that the biggest, most glaring thing that causes problems is the lack of static typing. It happens that when the compiler is unable to detect these issues, the end user is left to find them. This can be very potentially damaging to companies. And it is more prominent when you have 100k lines of code, not all of which one can be familiar with.
Lisp takes some steps to help solve these issues. SBCL has very good type inference capabilities, and can warn or error at compile time with type issues. Additionally, Common Lisp allows one to declare and assert argument types, but there’s no guarantee this information can be used.And what's SBCL? Let's cite from it's homepage: "Steel Bank Common Lisp (SBCL) is a high performance Common Lisp compiler". What? Even more surprises! Compilers, type inference, assertions? Ok, looks like (at least some of) the LISP hackers came to appreciate the static typing. Who would have thought it?
