Suffocating your programs with type definitions means you've already decided that whatever fancy architecture you've built should not be changed without a suitable amount of analysis paralysis.
- Jeremy Bowers (2020), Why Duck Typing Is Safe → http://www.jerf.org/iri/post/2954
- The interface must be simple enough to accidentally implement.
- The objects have to get mixed up.
- Something bad has to actually happen.
I'm not claiming the combination of these three things is impossible. It isn't. My point is that this is exceedingly rare, and it should be treated as such. It is not something one should spend precious, precious design budget on in a language's design to avoid.
Couple pretty interesting concepts here...
- Jakub T. Jankiewicz (2019), jquery.terminal → https://github.com/jcubic/jquery.terminal
JavaScript Library for Web Based Terminal Emulators
- Jakub T. Jankiewicz (2022), wayne → https://github.com/jcubic/wayne
Service Worker Routing library for in browser HTTP requests
- Spencer Mortensen (2020), Logic as Algebra → https://spencermortensen.com/articles/boolean-algebra/
The algebraic method [of constructing proofs] treats logic like high school algebra, where the values are limited to {0,1} instead of C, and the operators are the boolean operators. Constructing a proof amounts to solving a system of equations.
- Prabhakar Ragde (2022), Logic and Computation Intertwined → https://cs.uwaterloo.ca/~plragde/flaneries/LACI/
This flânerie is about the formalization of the idea of proof, and its application in computer science.
- eclipse.org (2022), The Epsilon Unit Testing Framework (EUnit) → https://www.eclipse.org/epsilon/doc/eunit/
EUnit is an unit testing framework specifically designed to test model management tasks, based on EOL and the Ant workflow tasks. It provides assertions for comparing models, files and directories. Tests can be reused with different sets of models and input data, and differences between the expected and actual models can be graphically visualized. This chapter describes how tests are organized and written and shows two examples of how a model-to-model transformation can be tested with EUnit. This chapter ends with a discussion of how EUnit can be extended to support other modelling and model management technologies.
- dafny-lang (2022), dafny: verification-aware programming language → https://github.com/dafny-lang/dafny
Dafny is a verification-ready programming language. As you type in your program, Dafny's verifier constantly looks over your shoulder, flags any errors, shows you counterexamples, and congratulates you when your code matches your specifications. When you're done, Dafny can compile your code to C#, Java, JavaScript or Go (more to come!), so it can integrate with your existing workflow.
- Scott Antipa (2022), Why we need a flowchart editor that doesn't give you carpal tunnel → https://www.scottantipa.com/why-knotend
This is a post about why I'm making knotend, a flowchart editor designed for speed, and why we need to get away from mouse-based flowchart editors.
- Simon Brown (2021), Getting started with
Structurizr Lite→ https://dev.to/simonbrown/getting-started-with-structurizr-lite-27d0- ... Diagrams as code → https://dev.to/simonbrown/diagrams-as-code-2-0-82k
- ... The
C4 modelfor visualising software architecture → https://c4model.com/
- Elliot Swart (2022), Introduction to Pragmatic Formal Modeling → https://elliotswart.github.io/pragmaticformalmodeling/
- Series that demonstrates symbolic logic modeling with
TLA+as an iterative process - similar to but not the same as TDD.
- Series that demonstrates symbolic logic modeling with
- Marc Brooker (2022), Simple Simulations for System Builders → https://brooker.co.za/blog/2022/04/11/simulation.html