While this may be an interesting/useful product, pointing to a lame video means you don’t understand the audience here.

This is one of my go-to sites: https://www.interaction-design.org/literature/book/the-encyclopedia-of-human-computer-interaction-2nd-ed and they also have courses.

Obviously, UI/UX/HCI is a huge area, so if there’s a particular focus (what kind of UI? for what purpose? etc.) that you have, I can make more specific suggestions.

A super common example for “clean code” is that instead of doing p * t to add sales tax, you write price * sales_tax. I pulled up an ecommerce suite and looked how they did it. They track an array of the tax markups, one for each applicable tax, and bundle that along with the cart.

btw, “clean code” (I hate that name, I prefer “intention revealing code”) is much more than nicely named variables, it’s well partitioned code at multiple levels. Short methods with meaningful names, divided into classes that are cohesive, divided into modules, etc., with cohesion at each level, and each one being at the same level of abstraction.

I took a look at the tax.php code and, while I’m no PHP developer, that’s not at all how I’d do it, because that code isn’t OO, it’s just code that happens to have method names. We can argue about OO vs. FP, but if I were to write this as OO code, I wouldn’t have code like this (in fact I’d hardly have if statements at all):

if ($calculate != 'P' && $calculate != 'F') {
	$amount += $tax_rate['amount'];
} elseif ($tax_rate['type'] == $calculate) {
	$amount += $tax_rate['amount'];
}

That’s a sign that the author doesn’t understand OOP, or didn’t want to do it.

Interesting hint system, but the part of the paper discussing how effective it was does not (to me) provide good evidence. Yes, there was an ~19% drop in attempts, but without controlling for (so many) other reasons for the drop, it’s impossible to say that, say, the Fall 2016 cohort had knowledge from the Fall 2015 cohort’s completion of the course. A randomized controlled study (some students getting useful hints, others getting unhelpful hints, and others getting no hints at all) would have provided better evidence.

Edit: This is not to say that the hints don’t provide benefit, they may, but there’s no evidence here to provide solid guidance to others.

Implementing Domain-Driven Design by Vaughn Vernon goes through an implementation of an application in Java using Evans’ DDD principles. I may disagree with some of his code, and some of the “dialog” is hokey, but it is a useful read.

I’ve been doing this coding thing for a while (30+ years) and I find it’s really difficult to convey how “real world” problems get solved, because much of the solutions are specific to the team and company culture involved, and less about the technical aspects. Yes, for those who give talks at QCon or O’Reilly conferences, they have unique problems, but 80% (if not much more) have the same issues: lack of modularity (hence monoliths), poorly written tests (let alone coverage), and a shallow understanding of the domain (which is why I talk a lot about domain-driven design).

I really liked the Architecture of Software Applications books, because it’s one of the few places that walks through how something that you might actually be using was created, and the constraints involved.

I also thought Practical API Design was a really good case study of writing a framework. Growing Object-Oriented Software (aka GOOS) is also a solid read (and generally matches how I think and do software development).

Yes, many books use toy or simplistic examples, partly because it’s really hard to teach someone a non-trivial domain while at the same time teaching them something non-trivial about a certain type of problem/solution, I also find most authors aren’t able to, or don’t want to, put in the work necessary to create more realistic examples. As an author and instructor, it definitely is more work, but is also a better way to teach. Alas, the bar is pretty low for how programming is taught.

Where YAML gets most of it’s bad reputation from is actually not from YAML but because some project (to name a few; Ansible, Salt, Helm, …) shoehorn a programming language into YAML by adding a template language on top. And then try to pretend that it’s declarative because YAML. YAML + Templating is as declarative as any languages that has branches and loops, except that YAML hasn’t been designed to be a programming language and it’s rather quite poor at it.

Gonna be hard for me to see .arc files as anything other than pre-zip compressed archives. :-D

I’m the author of the blog post and one of two authors of the guidelines. Any feedback is welcome.

It would be nice if there was an option to never establish a data link over the lightning port unless the device is unlocked. 7 days is a long window if your device is seized at customs or something.

Last week

• Posted Collaborative Software Trades. Seems like interest is too low for this to go anywhere, among other things.
• Tried to look up some recent animation libraries. Found popmotion and others by the same author.
• Cleaned up updates to guitktk from the week before (mainly a new SDL backend) and pushed them.

This week

• Maybe think up of projects for Collaborative Software Trades anyways and add them there.
• Maybe summarize my findings about animation.
• I want to keep working on the low level (for C/asm) visual program editor but might have to shelve it for a bit.

I still have a few of these from the JavaOne conference way back when.

They don’t allow you to give anything back to the open-source community. They want you to use those free libraries and give nothing back. And it is their corporate strategy. I doubt that’s the case.

At Apple, this is the corporate strategy, and is one of the reasons I left. When I left, there was definitely some moves to make contributing back to open-source easier (mainly to a few particular projects, such as Cassandra, Solr, and Kafka), but by no means was it easy. For all other projects, it simply wasn’t worth it to make the attempt due to the incredibly high overhead of management and legal for even small changes. If I have to write an email or fill out a form that is longer than my pull-request would be, then I’m not going to do it.

Fiction:

• Slogging my way through The Way of Kings by Brandon Sanderson. I say slogging, because it’s taking a lot of effort for me to not just put it aside. I’ve really enjoyed Sanderson’s other works (the entire Mistborn and Steelheart series are highly recommended), but I’m really having trouble with this one. I’ll keep pushing because there’s other books in the “Cosmere” universe that I want to read, but ask me again in a few weeks.

• Finished the trilogy of the “We Are Legion”(aka the “Bobiverse”), which was a fun read. I have Kindle Unlimited, so those books were free for me, and I’ve had some luck, both good and bad, with this. Makes it no-risk (other than my time) to try a book and if I don’t like it, return it and get another one.

Non-Fiction:

• Besides a ton of research papers on the subjects of instructional design and learning (to improve my training courses), I’m reading “The Experiential Educator” by Kolb, and “The Adult Learner” by Knowles, et al.

• Also doing reading on teaching organizational skills to kids with ADHD, e.g., Organizational Skills Training for Children with ADHD to see how I can help my 7th grade son.

Got my LLC together, a pretty painless process (even for California). Working on trademark filing next.

Looking into online Master’s degrees in Learning Design/Education as I continue to do “amateur” research in the area, but want a bit more rigor as well as feedback. My goal is to raise the level of online education from “lecture-ware” to courses that leverage our better understanding of learning.

For now, however, diving back into my online course on Java testing, after finishing 4 months of focusing on my on-site Java training classes for “new college grads” at a large company.

It’s sad that these attitudes are the exception rather than the rule in software development.

(Btw, I had to laugh at the image for “if (Developers.Happy()…” where earlier the “no ifs” idea was mentioned. :D

I wish all of Martin’s pages were dated, because this is from ~2004 (earlier, really) and this concept forms the basis of current Microservices principles. I don’t think Martin gets enough credit for how much current practice is based on his writings.

I wish I had a nickel for every tutorial or doc example that used “foo” or “bar” instead of a real-world(ish) example. I’d be rich and it’s awful and lazy.

I teach this stuff, so I see lots of code written by students that could be refactored to be much nicer, but really, it’s just not that hard to come up with more realistic examples at this level.

For a good example, see Trisha Gee’s series on JetBrains’ site. Posted to Lobsters: https://lobste.rs/s/nzntxj/code_smells_null.

How about unit-testing? I didn’t see anything obvious in the docs. It’d also be great if the question “why yet another front-end JavaScript framework” were answered in the GitHub repo (or docs). I found a partial answer here: https://www.sitepoint.com/hyperapp-1-kb-javascript-library/.

For my new business account (with custom domains), I’m using ProtonMail. I had used FastMail in the past, and it was fine, but I wanted to support the FOSS aspect of ProtonMail (pretty much the same price for both). I thought about running my own email server on Digital Ocean, but even at $5 a month, that’s more expensive than ProtonMail’s “Plus” plan ($48/year) or FastMail’s $50/year.

Split between the drudgery of setting up my new training company:

• Searching the awful US trademark database and filing for trademarks (myself, for now)
• Finding a lawyer/service to do my LLC creation (referrals welcome!)
• Searching and buying domains (Hexonet has some really good pricing and their new UI is not bad, otherwise Namecheap is still my go-to domain registry)
• Setting up dedicated email – ProtonMail seems really nice
• Trying to figure out where I’ll host the web site, for now just using Nearlyfreespeech.net since I’ve already got an account and it’s trivial to set up new domains, not to mention it’s dirt-cheap.
• Creating the basic home page (I really hate this part, getting things to look right still takes me forever).
• Linking the above to Mailchimp, analytics, getting a Stripe account, etc.

Whoa, ok, that was perhaps too much detail, but it’s really drudge-work, because I really want to get back to:

• Creating an online video course that uses the principles of domain-driven design, “ports & adapters” (aka hexagonal) architecture, testing as a first-class activity (not necessarily TDD), modern Java (8+), and built on top of Spring. This is based on a class I teach to new college grads, and it’s cool to see how much of what seems to be “advanced” work they can understand and apply. I’ve got all the code and it’s been fun teaching and building it.
• Working on a “teaser” course (of 3-4 hours) that I’ll probably put up on Udemy – I don’t really like their business model, but they’ve got a huge mindshare, so we’ll see.