TDD good habits manifesto

(principles)

• tests should test one thing only
  • test one logical assertion
  • don't mix assertions of state and collaboration in the same test
  • modifications of production code should only break related test cases
• each test should be self-contained, including data
• ensure tests are independent of each other
• don't refactor with a failing test
• organise your unit test projects to reflect your production code
• keep your tests and production code separate
  • do not use production data and code to test production code
• if your tests are difficult to write or maintain, consider changing the design

(red phase)

• create more specific tests to drive a more generic solution (Triangulate)
• give your tests meaningful names (behaviour / goal-oriented) that reflect your production system
• write the assertion first and work backwards
• see the test fail for the right reason
• ensure you have meaningful feedback from failing tests
• Organize your test in Arrange, Act and Assert blocks
  • Arrange (aka Given) – all necessary preconditions and inputs.
  • Act (aka When) – on the object or method under test.
  • Assert (aka Then) – that the expected results have occurred.

(green phase)

• write the simplest code to pass the test
  • write any code that makes you get to the refactor phase quicker
  • it is okay to write any code that you might improve at a later stage
• consider using Transformation Priority Premises to evolve your code

(refactor phase)

• refactor aggressively and constantly
• treat tests as first class code
• use the IDE to refactor quickly and safely
• refactor production and test code independently (except changing public interfaces)
• Use the Rule of 3 to tackle duplication
  • Code can be copied once, but when the same code is used three times, it should be refactored/extracted
• Remember that duplication is cheaper than the wrong abstractions

Everybody knows that getting up and moving around is pretty much mandatory to deal with the problems sitting causes.

Yoga provides a great set of movements that directly counteract the above problems.

I’m going to share five of my favorite poses, complete with instructions on how to do them, and the problems they solve.

How do you balance a daunting project list representing multiple roles and outcomes? David Allen chats with Meghan Wilker, a tech expert, mother of two, and GTD enthusiast. Listen as Meghan shares how she uses GTD in her work and family life.

Diesmal wollen wir unsere SOAP-Services testen. Doch wie teste ich einen Webservice aus einem Unit-Test heraus? Wie baut man einen Integrationstest? Und gibt es da nicht auch noch etwas dazwischen?

How is an expert OO developer to improve on their craft? By learning from other paradigms! These six principles of the functional style also apply to OO. Some are part of good practice already; some express patterns both old and new; all give us different ways of thinking about problems. For developers without expertise in functional programming, examples in Java and C# provide new techniques for writing clear, quality code.

Vue.JS ist in der Szene für Webentwicklung aktuell ein heißes Thema. Neben React und Angular ist Vue aktuell das drittgrößte Framework für Single Page Webanwendungen.
Wir tauchen in dieser Folge in die Technik ein und Fabi und Sebi schildern ihre Erfahrungen mit dem Bauen von Webapps mit Vue.

Part three of a series on modeling Java problems as folds, looking specifically at streams in Java 8.

So why bother with Java EE?

We are going to answer this question by showing how easy it is to build modern Java applications using most of the Java EE specs. And, the key ingredient to succeeding here is Eclipse Microprofile: enterprise Java in the age of microservices.

The application we are going to build is RESTful web API to manage people; it's as simple as that. The standard way to build RESTful web services in Java is by using JAX-RS 2.1 (JSR-370). Consequently, CDI 2.0 (JSR-365) is going to take care of dependency injection, whereas JPA 2.0 (JSR-317) is going to cover the data access layer. And certainly, Bean Validation 2.0 (JSR-380) is helping us to deal with input verification.

About this course
Skip Course Description

In order to be effective, leaders need a high tolerance of complexity. Beyond this, they need to inform their people and the outside world of their strategies, policies and decisions. Effective leaders are often inspiring communicators - their own high tolerance of complexity helps them reduce this complexity to a concise and powerful message.

Your sensemaking mindset is therefore of critical importance to motivate others to follow and support you. Your ability to inspire and convince is largely dependent on the way you frame your message, and on your skills at playing the game of framing and reframing. You will learn from a large variety of (video) cases and analyse a large number of situations where leaders’ communication and sensemaking skills are tested and probed. This will ensure that you are equipped to build winning coalitions in your own organization.

What you'll learn

How to derive a concise message from a complex situation
How to use framing and reframing effectively to achieve your goals 
How to gain support from senior management and your teams
Develop and apply a sensemaking mindset

This repository contains all my GNU Emacs configuration.

inkl. links to posts

der grund, morgens aufzustehen

There’s nothing I can praise about Magit that hasn’t been written in a dozen blogs already, but since Jonas started a kickstarter campaign for it I knew I had to say something. If you use Magit, you already know the greatness of it. And if you don’t, hopefully I can convince you to try it in time to back the campaign.

Being able to duplicate current line

Move or drag a line up and down

Use multiple cursors to edit at a time

Auto-completion of variables and functions name

Fuzzy file search i.e. Ctrl-P or Cmd-Shift-o in other editors

Searching a term of string in the whole project

A tree view of the project to explore file ...