The Programmer's Brain, by Felienne Hermans is an uncommon off-shoot of a common book topic – improving your programming and how you learn programming.
The uncommon part is that it looks at the problem in a different way – what happens to the brain, say, when you are learning a new programming language? And how can you optimize that?
The book talks a bit about the different parts of memory – short term memory, working memory, and long term memory, and then looks – based on actual research – on the best way to do a number of tasks, including learning a language, adding a feature, problem solving, onboarding a new team member, and others.
It also has exercises to support it.
The one practice I have used for a while, and it is easy to do, is using a spaced repetition system (or regular flashcards, although to me that seems harder to keep up with) to learn syntax or important details on a language or framework. Personally I like Anki.
I will certainly look into several of the other suggested practices.
I have just finished Creating Maintainable Contexts for Automated Testing by Mel Grubb, on Pluralsight (yes, that title is quite a mouthful!)
I haven't really bothered with reviews of most courses I take – counting this one I watched 43 this year – a bunch on Pluralsight, some MBA courses, and 14 non-fiction books. This one was interesting enough that it was worth mentioning.
It covers ways to make your test code cleaner. What I liked:
using a Random library to document what is boilerplate on a test is what is important – name = library.RandomName() is very different from name = “Luiz Marques”, as it shows that it has no particular importance.
From the next step, adding Mother objects, which are simple static classes that return ready to go instances – such as .Simple() and .Typical(). If you need to, you can then change anything that is important for the test, and it will be very obvious. As a bonus, any changes to the objects (such as an added property) can be dealt on a single place, instead of having to be fixed on possibly dozens of tests.
Converting the mothers to the Builder pattern, which makes thing slightly clearer (but adds a lot of code), improving discoverability and makes it easier to change objects.
Using CSX to auto-generate most of the builder objects on each build.
Overall, very interesting, and well worth the time, specially if you already have Pluralsight.
The Most Important Thing Illuminated, by Howard Marks, covers a few principles for what he calls the superior investor – as if you are not going to be superior, you might as well just invest in index funds and not waste any time.
When I heard about the book, it was the regular version, but I believed the extra blocks of explanations – by famous investors as well as the author of the book – would be worth the extra time, and they were (I really which the font on the comments wasn't so small, though).
Most of the insights seem a little silly in summary form, but the details on how to handle them felt very useful to me – and I am very far from being a pro in the area.
Testing Business Ideas, by David J. Bland and Alexander Osterwalder, is a business book. I read The Lean Startup earlier this year, which talks a lot about the need to validate your ideas (you know, before you bet your whole company on your assumptions).
I knew a few ways myself, but this book goes deep into the various ways, how useful the evidence from them is, the best ways to do them and how they connect, including examples in some cases. Usually several pages worth per method, including some very useful ideas on the best way to implement them.
There are classics, such as customer interview, expert stakeholder interviews, e-mail campaigns, online ads, link tracking, customer support analysis, and many many more.
Domain Driven Design Fundamentals is a course by Julie Lerman and Steve Smith on Pluralsight . I had already seen several courses by Steve Smith (such as Kanban: Getting Started), and was interested in the topic, so I started it right way after PS notified me of the new course.
This is what Wikipedia uses for a definition of DDD:
“Domain-driven design (DDD) is the concept that the structure and language of software code (class names, class methods, class variables) should match the business domain. For example, if a software processes loan applications, it might have classes such as LoanApplication and Customer, and methods such as AcceptOffer and Withdraw.
DDD connects the implementation to an evolving model. Insert in your articleDomain-driven design is predicated on the following goals:
placing the project's primary focus on the core domain and domain logic;
basing complex designs on a model of the domain;
initiating a creative collaboration between technical and domain experts to iteratively refine a conceptual model that addresses particular domain problems.
The term was coined by Eric Evans in his book of the same title.”
While some of this seems less relevant, I think that the overall concept seems great.
And in this particular course, I really liked the example code. It covers making large parts of a Veterinary system for scheduling, complete with a Blazor app and a backend that includes e-mail confirmations, RabbitMQ, and a whole lot of interesting bits. It also has docker images, which can very helpful in projects with a lot of moving parts.
Screpy is a tool that scans your websites and gives you a lot of information on it.
List of your pages
Page speed for all your pages
Keyword Tracking (with support for specific locations, which can be useful, for obvious reasons)
SEO reports (it certainly found a lot of stuff in my main site) – it is supposed to be AI-Enhanced, but I have no idea what that is in this case.
Finding keywords and keyword clusters
I just got it, but I really like it so far. It looks amazing (I wish my site looked like this…), and it has a ton of suggestions (many, unfortunately, that I already knew I had to get around to), and also some I had no idea.
Some of the tasks it added:
Removed Unused CSS Rules
Broken canonical link
Meta Description not found
Use responsive images
Too Small Font Sizes
and a whole lot more (they have priorities too, which seems like a good idea on a list that big)
There are very large explanation boxes in each of those items, too.
The dashboard view is pretty much excellent, and shows a lot of information. I'd add more graphics, but right now it is kind of embarrassing…
I actually already had tools that supposedly did pretty much everything this does, in one form or another, but their approach and the ability to do all of that in a single place is great.
So far, all the suggestions I've seen make sense (which has NOT always been the case with other tools – a lot of false positives here and there).
Also, some had subscriptions, which I won't need anymore…
It seems to have a lot of video tutorials, which is good, because there is a lot I don't know how to get to yet (unfortunately I can't seem to full screen some of these, so they are super tiny and hard to see…).
Not surprisingly, they have various limits on numbers of pages, projects, etc depending on the level you subscribe at. I got the basic Appsumo subscription, which seemed adequate for my purposes. Another thing that changes with your user level is the time for analysis to repeat, in my case it is 7 days and supposedly it will also look for new pages, which is obviously better than having to go back to do manual refreshes.
Implementing Lean Software Development: From Concept to Cash, by Mary Poppendieck and Tom Poppendieck is a bit old by now, but after taking a few courses on Lean practices, it is easy to see the references to this book.
And even better, some of these courses were rather generic (for use of Lean as a general practice), and this one is more specific to software.
While I did use the equivalent of some of the lean practices (specially the quick releases to get feedback), I mostly didn't test assumptions before releases, as it doesn't always make sense (sometimes it is worth developing something for the exercise or because you want to use it yourself). There are, of course, many other parts to lean practices, but this stuck with me because it is a big part of The Lean Startup, which I also read recently.
I learned a lot from this, and although a lot don't apply to me (mostly the team/large enterprise stuff), a lot does, and I will keep it in mind.
Overall, strongly recommend for developers and all interested in applying lean practices. I read the Safari version.
Kanban is an interesting methodology that can be used in many places – it became common in manufacturing after Toyota invented and had great success, and it can also be useful in daily life and software development.
Kanban is about maximizing flow in systems, which is usually very useful, reducing waste and helping find bottlenecks.
It is also relatively simple, vs scrum and more complicated methods, and can be used in many different ways.
I particularly like that the course had a separate section for single and team use. Some specific services (such as Trello) are mentioned, but mostly briefly. As also are physical boards.
Overall, I found this course quite useful, and it certainly left me interested in using Kanban in practice.